home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update28.zoo / libg++ / src / diffcc next >
Encoding:
Text File  |  1993-02-22  |  97.4 KB  |  4,033 lines
  1. *** 1.11    1992/12/28 07:42:38
  2. --- Changelo    1993/02/22 17:06:27
  3. ***************
  4. *** 291,293 ****
  5. --- 291,298 ----
  6.       i have done allthe non-io classes. still working on those.
  7.   
  8.   ---------------------------- Patchlevel 16 -----------------------------------
  9. + 
  10. + *.cc:: ++jrb
  11. +     sync up with rest of libg++-2.3. all classes done now.
  12. + 
  13. + ---------------------------- Patchlevel 17 -----------------------------------
  14. *** 1.11    1992/12/28 07:42:38
  15. --- PatchLev.h    1993/02/22 17:06:28
  16. ***************
  17. *** 1,5 ****
  18.   
  19. ! #define    PatchLevel "16"
  20.   
  21.   /*
  22.    *    the Patch Level above is to identify the version
  23. --- 1,5 ----
  24.   
  25. ! #define    PatchLevel "17"
  26.   
  27.   /*
  28.    *    the Patch Level above is to identify the version
  29. *** 1.2    1992/06/03 02:12:17
  30. --- editbuf.cc    1993/02/22 17:06:30
  31. ***************
  32. *** 102,108 ****
  33.       gap_right (pos);
  34.   }
  35.   
  36. ! void edit_buffer::gap_left (size_t pos)
  37.   {
  38.     register buf_char *to, *from;
  39.     register long i;
  40. --- 102,108 ----
  41.       gap_right (pos);
  42.   }
  43.   
  44. ! void edit_buffer::gap_left (_G_size_t pos)
  45.   {
  46.     register buf_char *to, *from;
  47.     register long i;
  48. ***************
  49. *** 153,159 ****
  50.   /*  QUIT;*/
  51.   }
  52.   
  53. ! void edit_buffer::gap_right (size_t pos)
  54.   {
  55.     register buf_char *to, *from;
  56.     register long i;
  57. --- 153,159 ----
  58.   /*  QUIT;*/
  59.   }
  60.   
  61. ! void edit_buffer::gap_right (_G_size_t pos)
  62.   {
  63.     register buf_char *to, *from;
  64.     register long i;
  65. ***************
  66. *** 209,215 ****
  67.   {
  68.     register buf_char *p1, *p2, *lim;
  69.     buf_char *old_data = data;
  70. !   int long s1 = size1();
  71.   
  72.     if (gap_size() >= k)
  73.       return;
  74. --- 209,215 ----
  75.   {
  76.     register buf_char *p1, *p2, *lim;
  77.     buf_char *old_data = data;
  78. !   long s1 = size1();
  79.   
  80.     if (gap_size() >= k)
  81.       return;
  82. ***************
  83. *** 428,434 ****
  84.   // Called by fseek(fp, pos, whence) if fp is bound to a edit_buffer.
  85.   
  86.   streampos edit_streambuf::seekoff(streamoff offset, _seek_dir dir,
  87. !                   int mode=ios::in|ios::out)
  88.   {
  89.       struct edit_buffer *buffer = str->buffer;
  90.       disconnect_gap_from_file(buffer);
  91. --- 428,434 ----
  92.   // Called by fseek(fp, pos, whence) if fp is bound to a edit_buffer.
  93.   
  94.   streampos edit_streambuf::seekoff(streamoff offset, _seek_dir dir,
  95. !                   int mode /* =ios::in|ios::out*/)
  96.   {
  97.       struct edit_buffer *buffer = str->buffer;
  98.       disconnect_gap_from_file(buffer);
  99. ***************
  100. *** 586,592 ****
  101.   edit_buffer::edit_buffer()
  102.   {
  103.       buf_size = /*200;*/ 15; /* for testing! */
  104. !     data = malloc(buf_size);
  105.       files = NULL;
  106.   #ifndef OLD_STDIO
  107.       _gap_start = data;
  108. --- 586,592 ----
  109.   edit_buffer::edit_buffer()
  110.   {
  111.       buf_size = /*200;*/ 15; /* for testing! */
  112. !     data = (buf_char*)malloc(buf_size);
  113.       files = NULL;
  114.   #ifndef OLD_STDIO
  115.       _gap_start = data;
  116. ***************
  117. *** 611,617 ****
  118.       chain = buf->start_mark.chain;
  119.       buf->start_mark.chain = this;
  120.       mark_pointer size1 = buf->size1() << 1;
  121. !     size_t gap_size = buf->gap_size() << 1;
  122.       delta <<= 1;
  123.   
  124.       // check if new and old marks are opposite sides of gap
  125. --- 611,617 ----
  126.       chain = buf->start_mark.chain;
  127.       buf->start_mark.chain = this;
  128.       mark_pointer size1 = buf->size1() << 1;
  129. !     _G_size_t gap_size = buf->gap_size() << 1;
  130.       delta <<= 1;
  131.   
  132.       // check if new and old marks are opposite sides of gap
  133. ***************
  134. *** 647,653 ****
  135.       *ptr = this->chain;
  136.   }
  137.   
  138. ! size_t edit_string::length() const
  139.   {
  140.       ptrdiff_t delta = end->ptr(buffer) - start->ptr(buffer);
  141.       if (end->ptr(buffer) <= buffer->gap_start() ||
  142. --- 647,653 ----
  143.       *ptr = this->chain;
  144.   }
  145.   
  146. ! _G_size_t edit_string::length() const
  147.   {
  148.       ptrdiff_t delta = end->ptr(buffer) - start->ptr(buffer);
  149.       if (end->ptr(buffer) <= buffer->gap_start() ||
  150. ***************
  151. *** 656,665 ****
  152.       return delta - buffer->gap_size();
  153.   }
  154.   
  155. ! buf_char * edit_string::copy_bytes(size_t *lenp) const
  156.   {
  157.       char *new_str;
  158. !     size_t len1, len2;
  159.       buf_char *start1, *start2;
  160.       start1 = start->ptr(buffer);
  161.       if (end->ptr(buffer) <= buffer->gap_start()
  162. --- 656,665 ----
  163.       return delta - buffer->gap_size();
  164.   }
  165.   
  166. ! buf_char * edit_string::copy_bytes(_G_size_t *lenp) const
  167.   {
  168.       char *new_str;
  169. !     _G_size_t len1, len2;
  170.       buf_char *start1, *start2;
  171.       start1 = start->ptr(buffer);
  172.       if (end->ptr(buffer) <= buffer->gap_start()
  173. ***************
  174. *** 691,697 ****
  175.   {
  176.       edit_streambuf dst_file(this, ios::out);
  177.       if (buffer == src->buffer /*&& ???*/) { /* overly conservative */
  178. !     size_t src_len;
  179.       buf_char *new_str;
  180.       new_str = src->copy_bytes(&src_len);
  181.       dst_file.sputn(new_str, src_len);
  182. --- 691,697 ----
  183.   {
  184.       edit_streambuf dst_file(this, ios::out);
  185.       if (buffer == src->buffer /*&& ???*/) { /* overly conservative */
  186. !     _G_size_t src_len;
  187.       buf_char *new_str;
  188.       new_str = src->copy_bytes(&src_len);
  189.       dst_file.sputn(new_str, src_len);
  190. *** 1.8    1992/12/11 19:39:04
  191. --- filebuf.cc    1993/02/22 17:06:31
  192. ***************
  193. *** 17,23 ****
  194.   
  195.   #include <ioprivat.h>
  196.   #include <sys/types.h>
  197. - #include <sys/file.h>
  198.   #include <sys/stat.h>
  199.   #include <fcntl.h>
  200.   #include <errno.h>
  201. --- 17,22 ----
  202. ***************
  203. *** 76,105 ****
  204.       _fb._fileno = -1;
  205.   }
  206.   
  207. - void streambuf::_un_link()
  208. - {
  209. -     if (_flags & _S_LINKED) {
  210. -     streambuf **f;
  211. -     for (f = &_list_all; *f != NULL; f = &(*f)->xchain()) {
  212. -         if (*f == this) {
  213. -         *f = xchain();
  214. -         break;
  215. -         }
  216. -     }
  217. -     _flags &= ~_S_LINKED;
  218. -     }
  219. - }
  220. - 
  221. - void streambuf::_link_in()
  222. - {
  223. -     if ((_flags & _S_LINKED) == 0) {
  224. -     _flags |= _S_LINKED;
  225. -     xchain() = _list_all;
  226. -     _list_all = this;
  227. -     }
  228. - }
  229. - 
  230. - 
  231.   filebuf::filebuf() : backupbuf(CLOSED_FILEBUF_FLAGS)
  232.   {
  233.       init();
  234. --- 75,80 ----
  235. ***************
  236. *** 111,117 ****
  237.       attach(fd);
  238.   }
  239.   
  240. ! filebuf::filebuf(int fd, char* p, size_t len) : backupbuf(CLOSED_FILEBUF_FLAGS)
  241.   {
  242.       init();
  243.       attach(fd);
  244. --- 86,92 ----
  245.       attach(fd);
  246.   }
  247.   
  248. ! filebuf::filebuf(int fd, char* p, _G_size_t len) : backupbuf(CLOSED_FILEBUF_FLAGS)
  249.   {
  250.       init();
  251.       attach(fd);
  252. ***************
  253. *** 127,136 ****
  254.   }
  255.   
  256.   #ifdef atarist
  257. ! extern "C" extern int __default_mode__;
  258.   #endif
  259.   
  260. ! filebuf* filebuf::open(const char *filename, int mode, int prot)
  261.   {
  262.       if (is_open())
  263.       return NULL;
  264. --- 102,111 ----
  265.   }
  266.   
  267.   #ifdef atarist
  268. ! extern "C" int __default_mode__;
  269.   #endif
  270.   
  271. ! filebuf* filebuf::open(const char *filename, ios::openmode mode, int prot)
  272.   {
  273.       if (is_open())
  274.       return NULL;
  275. ***************
  276. *** 139,149 ****
  277.   #ifdef atarist
  278.       int rw_mode = (__default_mode__) ? _S_IS_BINARY : 0;
  279.   #endif
  280.       if ((mode & (ios::in|ios::out)) == (ios::in|ios::out)) {
  281.       posix_mode = O_RDWR;
  282.       read_write = 0;
  283.       }
  284. !     else if (mode & (ios::out|ios::app))
  285.       posix_mode = O_WRONLY, read_write = _S_NO_READS;
  286.       else if (mode & (int)ios::in)
  287.       posix_mode = O_RDONLY, read_write = _S_NO_WRITES;
  288. --- 114,126 ----
  289.   #ifdef atarist
  290.       int rw_mode = (__default_mode__) ? _S_IS_BINARY : 0;
  291.   #endif
  292. +     if (mode & ios::app)
  293. +     mode |= ios::out;
  294.       if ((mode & (ios::in|ios::out)) == (ios::in|ios::out)) {
  295.       posix_mode = O_RDWR;
  296.       read_write = 0;
  297.       }
  298. !     else if (mode & ios::out)
  299.       posix_mode = O_WRONLY, read_write = _S_NO_READS;
  300.       else if (mode & (int)ios::in)
  301.       posix_mode = O_RDONLY, read_write = _S_NO_WRITES;
  302. ***************
  303. *** 152,158 ****
  304.       if ((mode & (int)ios::trunc) || mode == (int)ios::out)
  305.       posix_mode |= O_TRUNC;
  306.       if (mode & ios::app)
  307. !     posix_mode |= O_APPEND;
  308.       if (!(mode & (int)ios::nocreate) && mode != ios::in)
  309.       posix_mode |= O_CREAT;
  310.       if (mode & (int)ios::noreplace)
  311. --- 129,135 ----
  312.       if ((mode & (int)ios::trunc) || mode == (int)ios::out)
  313.       posix_mode |= O_TRUNC;
  314.       if (mode & ios::app)
  315. !     posix_mode |= O_APPEND, read_write |= _S_IS_APPENDING;
  316.       if (!(mode & (int)ios::nocreate) && mode != ios::in)
  317.       posix_mode |= O_CREAT;
  318.       if (mode & (int)ios::noreplace)
  319. ***************
  320. *** 167,177 ****
  321.       else if(mode & (int)ios::text)
  322.       rw_mode &= ~_S_IS_BINARY;
  323.       read_write |= rw_mode;
  324. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES)|rw_mode);
  325.   #else
  326. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES);
  327.   #endif
  328. !     if (mode & ios::ate) {
  329.       if (seekoff(0, ios::end) == EOF)
  330.           return NULL;
  331.       }
  332. --- 144,154 ----
  333.       else if(mode & (int)ios::text)
  334.       rw_mode &= ~_S_IS_BINARY;
  335.       read_write |= rw_mode;
  336. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING)|rw_mode);
  337.   #else
  338. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING);
  339.   #endif
  340. !     if (mode & (ios::ate|ios::app)) {
  341.       if (seekoff(0, ios::end) == EOF)
  342.           return NULL;
  343.       }
  344. ***************
  345. *** 202,208 ****
  346.         case 'a':
  347.       omode = O_WRONLY;
  348.       oflags = O_CREAT|O_APPEND;
  349. !     read_write = _S_NO_READS;
  350.       break;
  351.   #ifdef atarist
  352.         case 'b':
  353. --- 179,185 ----
  354.         case 'a':
  355.       omode = O_WRONLY;
  356.       oflags = O_CREAT|O_APPEND;
  357. !     read_write = _S_NO_READS|_S_IS_APPENDING;
  358.       break;
  359.   #ifdef atarist
  360.         case 'b':
  361. ***************
  362. *** 226,235 ****
  363.       _fb._fileno = fdesc;
  364.   #ifdef atarist
  365.       read_write |= rw_mode;
  366. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES)|rw_mode);
  367.   #else
  368. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES);
  369.   #endif
  370.       _link_in();
  371.       return this;
  372.   }
  373. --- 203,215 ----
  374.       _fb._fileno = fdesc;
  375.   #ifdef atarist
  376.       read_write |= rw_mode;
  377. !     xsetflags(read_write, (_S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING)|rw_mode);
  378.   #else
  379. !     xsetflags(read_write, _S_NO_READS+_S_NO_WRITES+_S_IS_APPENDING);
  380.   #endif
  381. +     if (read_write & _S_IS_APPENDING)
  382. +     if (seekoff(0, ios::end) == EOF)
  383. +         return NULL;
  384.       _link_in();
  385.       return this;
  386.   }
  387. ***************
  388. *** 240,255 ****
  389.       return NULL;
  390.       _fb._fileno = fd;
  391.   #ifdef atarist
  392. !     xsetflags(_S_DELETE_DONT_CLOSE |((__default_mode__)? _S_IS_BINARY : 0),
  393. !           (_S_DELETE_DONT_CLOSE+_S_NO_READS+_S_NO_WRITES) |
  394. !            ((__default_mode__)? _S_IS_BINARY : 0));
  395.   #else
  396. !     xsetflags(_S_DELETE_DONT_CLOSE,
  397. !           _S_DELETE_DONT_CLOSE+_S_NO_READS+_S_NO_WRITES);
  398.   #endif
  399.       return this;
  400.   }
  401.   
  402.   int filebuf::overflow(int c)
  403.   {
  404.       if (xflags() & _S_NO_WRITES) // SET ERROR
  405. --- 220,242 ----
  406.       return NULL;
  407.       _fb._fileno = fd;
  408.   #ifdef atarist
  409. !     xsetflags((__default_mode__)? _S_IS_BINARY : 0,
  410. !       (_S_NO_READS+_S_NO_WRITES) | ((__default_mode__) ? _S_IS_BINARY : 0));
  411.   #else
  412. !     xsetflags(0, _S_NO_READS+_S_NO_WRITES);
  413.   #endif
  414.       return this;
  415.   }
  416.   
  417. + streambuf* filebuf::setbuf(char* p, _G_size_t len)
  418. + {
  419. +     if (streambuf::setbuf(p, len) == NULL)
  420. +     return NULL;
  421. +     setp(_base, _base);
  422. +     setg(_base, _base, _base);
  423. +     return this;
  424. + }
  425. + 
  426.   int filebuf::overflow(int c)
  427.   {
  428.       if (xflags() & _S_NO_WRITES) // SET ERROR
  429. ***************
  430. *** 289,295 ****
  431.       return (EOF);
  432.   #endif
  433.   
  434. !    if (xflags() & _S_NO_READS)
  435.       return EOF;
  436.       if (gptr() < egptr())
  437.       return *(unsigned char*)gptr();
  438. --- 276,282 ----
  439.       return (EOF);
  440.   #endif
  441.   
  442. !     if (xflags() & _S_NO_READS)
  443.       return EOF;
  444.       if (gptr() < egptr())
  445.       return *(unsigned char*)gptr();
  446. ***************
  447. *** 305,312 ****
  448.       if (do_flush()) return EOF;
  449.   #endif
  450.   
  451. -     switch_to_get_mode();
  452. - 
  453.       _G_ssize_t count = sys_read(base(), ebuf() - base());
  454.       if (count <= 0) {
  455.       if (count == 0)
  456. --- 292,297 ----
  457. ***************
  458. *** 323,333 ****
  459.       return *(unsigned char*)gptr();
  460.   }
  461.   
  462. ! int filebuf::do_write(const char *data, int to_do)
  463.   {
  464.       if (to_do == 0)
  465.       return 0;
  466. !     if (egptr() != pbase()) {
  467.       long new_pos = sys_seek(pbase()-egptr(), ios::cur);
  468.       if (new_pos == -1)
  469.           return EOF;
  470. --- 308,326 ----
  471.       return *(unsigned char*)gptr();
  472.   }
  473.   
  474. ! int filebuf::do_write(const char *data, _G_size_t to_do)
  475.   {
  476.       if (to_do == 0)
  477.       return 0;
  478. !     if (xflags() & _S_IS_APPENDING) {
  479. !     // On a system without a proper O_APPEND implementation,
  480. !     // you would need to sys_seek(0, ios::end) here, but is
  481. !     // is not needed nor desirable for Unix- or Posix-like systems.
  482. !     // Instead, just indicate that offset (before and after) is
  483. !     // unpredictable.
  484. !     _fb._offset = -1;
  485. !     }
  486. !     else if (egptr() != pbase()) {
  487.       long new_pos = sys_seek(pbase()-egptr(), ios::cur);
  488.       if (new_pos == -1)
  489.           return EOF;
  490. ***************
  491. *** 372,377 ****
  492. --- 365,373 ----
  493.       streampos result, new_offset, delta;
  494.       _G_ssize_t count;
  495.   
  496. +     if (mode == 0) // Don't move any pointers.
  497. +     dir = ios::cur, offset = 0;
  498. + 
  499.       // Flush unwritten characters.
  500.       // (This may do an unneeded write if we seek within the buffer.
  501.       // But to be able to switch to reading, we would need to set
  502. ***************
  503. *** 417,423 ****
  504.       // If destination is within current buffer, optimize:
  505.       if (_fb._offset >= 0 && _eback != NULL) {
  506.       // Offset relative to start of main get area.
  507. !     fpos_t rel_offset = offset - _fb._offset
  508.           + (eGptr()-Gbase());
  509.       if (rel_offset >= 0) {
  510.           if (in_backup())
  511. --- 413,419 ----
  512.       // If destination is within current buffer, optimize:
  513.       if (_fb._offset >= 0 && _eback != NULL) {
  514.       // Offset relative to start of main get area.
  515. !     _G_fpos_t rel_offset = offset - _fb._offset
  516.           + (eGptr()-Gbase());
  517.       if (rel_offset >= 0) {
  518.           if (in_backup())
  519. ***************
  520. *** 429,435 ****
  521.           }
  522.           // If we have streammarkers, seek forward by reading ahead.
  523.           if (have_markers()) {
  524. !         int to_skip = rel_offset - (_gptr - _eback);
  525.           if (ignore(to_skip) != to_skip)
  526.               goto dumb;
  527.           return offset;
  528. --- 425,431 ----
  529.           }
  530.           // If we have streammarkers, seek forward by reading ahead.
  531.           if (have_markers()) {
  532. !         long to_skip = rel_offset - (_gptr - _eback);
  533.           if (ignore(to_skip) != to_skip)
  534.               goto dumb;
  535.           return offset;
  536. ***************
  537. *** 512,541 ****
  538.   _G_ssize_t filebuf::sys_read(char* buf, size_t size)
  539.   {
  540.       for (;;) {
  541.       _G_ssize_t count = ::read(_fb._fileno, buf, size);
  542.       if (count != -1 || errno != EINTR)
  543.           return count;
  544.       }
  545.   }
  546.   
  547. ! fpos_t filebuf::sys_seek(fpos_t offset, _seek_dir dir)
  548.   {
  549.       return ::lseek(fd(), offset, (int)dir);
  550.   }
  551.   
  552. ! _G_ssize_t filebuf::sys_write(const void *buf, long n)
  553.   {
  554.       long to_do = n;
  555.       while (to_do > 0) {
  556.       _G_ssize_t count = ::write(fd(), buf, to_do);
  557.       if (count == EOF) {
  558.           if (errno == EINTR)
  559.           continue;
  560. !         else
  561.           break;
  562.       }
  563.       to_do -= count;
  564. !     buf += count;
  565.       }
  566.       n -= to_do;
  567.       if (_fb._offset >= 0)
  568. --- 508,547 ----
  569.   _G_ssize_t filebuf::sys_read(char* buf, size_t size)
  570.   {
  571.       for (;;) {
  572. + #ifdef atarist
  573. +     _G_ssize_t count = ::_read(_fb._fileno, buf, size);
  574. + #else
  575.       _G_ssize_t count = ::read(_fb._fileno, buf, size);
  576. + #endif
  577.       if (count != -1 || errno != EINTR)
  578.           return count;
  579.       }
  580.   }
  581.   
  582. ! _G_fpos_t filebuf::sys_seek(_G_fpos_t offset, _seek_dir dir)
  583.   {
  584.       return ::lseek(fd(), offset, (int)dir);
  585.   }
  586.   
  587. ! _G_ssize_t filebuf::sys_write(const void *buf, _G_size_t n)
  588.   {
  589.       long to_do = n;
  590.       while (to_do > 0) {
  591. + #ifdef atarist
  592. +     _G_ssize_t count = ::_write(fd(), buf, to_do);
  593. + #else
  594.       _G_ssize_t count = ::write(fd(), buf, to_do);
  595. + #endif
  596.       if (count == EOF) {
  597.           if (errno == EINTR)
  598.           continue;
  599. !         else {
  600. !         _flags |= _S_ERR_SEEN;
  601.           break;
  602. +         }
  603.       }
  604.       to_do -= count;
  605. !     buf = (void*)((char*)buf + count);
  606.       }
  607.       n -= to_do;
  608.       if (_fb._offset >= 0)
  609. ***************
  610. *** 553,569 ****
  611.       return ::close(fd());
  612.   }
  613.   
  614. ! size_t filebuf::sputn(const char *s, size_t n)
  615.   {
  616. !     if (n <= 0)
  617.       return 0;
  618.       // This is an optimized implementation.
  619.       // If the amount to be written straddles a block boundary
  620.       // (or the filebuf is unbuffered), use sys_write directly.
  621.   
  622. !     // First fill the buffer.
  623. !     int to_do = n;
  624. !     int count = _epptr - _pptr; // Space available.
  625.       if (count > 0) {
  626.       if (count > to_do)
  627.           count = to_do;
  628. --- 559,589 ----
  629.       return ::close(fd());
  630.   }
  631.   
  632. ! _G_size_t filebuf::xsputn(const char *s, _G_size_t n)
  633.   {
  634. !     if (n == 0)
  635.       return 0;
  636.       // This is an optimized implementation.
  637.       // If the amount to be written straddles a block boundary
  638.       // (or the filebuf is unbuffered), use sys_write directly.
  639.   
  640. !     _G_size_t to_do = n;
  641. !     int must_flush = 0;
  642. !     // First figure out how much space is available in the buffer.
  643. !     _G_size_t count = _epptr - _pptr; // Space available.
  644. !     if (linebuffered() && (_flags & _S_CURRENTLY_PUTTING)) {
  645. !     count =_ebuf - _pptr;
  646. !     if (count >= n) {
  647. !         for (register const char *p = s + n; p > s; ) {
  648. !         if (*--p == '\n') {
  649. !             count = p - s + 1;
  650. !             must_flush = 1;
  651. !             break;
  652. !         }
  653. !         }
  654. !     }
  655. !     }
  656. !     // Then fill the buffer.
  657.       if (count > 0) {
  658.       if (count > to_do)
  659.           count = to_do;
  660. ***************
  661. *** 573,584 ****
  662.       }
  663.       else {
  664.           register char *p = pptr();;
  665. !         for (register int i = count; --i >= 0; ) *p++ = *s++;
  666.       }
  667.       pbump(count);
  668.       to_do -= count;
  669.       }
  670. !     if (to_do > 0) {
  671.       // Next flush the (full) buffer.
  672.       if (__overflow(this, EOF) == EOF)
  673.           return n - to_do;
  674. --- 593,604 ----
  675.       }
  676.       else {
  677.           register char *p = pptr();;
  678. !         for (register _G_size_t i = count+1; --i > 0; ) *p++ = *s++;
  679.       }
  680.       pbump(count);
  681.       to_do -= count;
  682.       }
  683. !     if (to_do + must_flush > 0) {
  684.       // Next flush the (full) buffer.
  685.       if (__overflow(this, EOF) == EOF)
  686.           return n - to_do;
  687. ***************
  688. *** 585,592 ****
  689.   
  690.       // Try to maintain alignment: write a whole number of blocks.
  691.       // dont_write is what gets left over.
  692. !     int block_size = _ebuf - _base;
  693. !     int dont_write = block_size >= 128 ? to_do % block_size : 0;
  694.   
  695.       _G_ssize_t count = to_do - dont_write;
  696.       if (do_write(s, count) == EOF)
  697. --- 605,612 ----
  698.   
  699.       // Try to maintain alignment: write a whole number of blocks.
  700.       // dont_write is what gets left over.
  701. !     _G_size_t block_size = _ebuf - _base;
  702. !     _G_size_t dont_write = block_size >= 128 ? to_do % block_size : 0;
  703.   
  704.       _G_ssize_t count = to_do - dont_write;
  705.       if (do_write(s, count) == EOF)
  706. ***************
  707. *** 602,609 ****
  708.       return n - to_do;
  709.   }
  710.   
  711. ! size_t filebuf::sgetn(char *s, size_t n)
  712.   {
  713.       // FIXME: OPTIMIZE THIS (specifically, when unbuffered()).
  714. !     return streambuf::sgetn(s, n);
  715.   }
  716. --- 622,632 ----
  717.       return n - to_do;
  718.   }
  719.   
  720. ! _G_size_t filebuf::xsgetn(char *s, _G_size_t n)
  721.   {
  722.       // FIXME: OPTIMIZE THIS (specifically, when unbuffered()).
  723. !     return streambuf::xsgetn(s, n);
  724.   }
  725. + 
  726. + // Non-ANSI AT&T-ism:  Default open protection.
  727. + const int filebuf::openprot = 0644;
  728. *** 1.3    1992/07/17 18:24:43
  729. --- fstream.cc    1993/02/22 17:06:32
  730. ***************
  731. *** 22,59 ****
  732.   #pragma implementation
  733.   #endif
  734.   
  735. ! ifstream::ifstream()
  736.   {
  737. !     _strbuf = new filebuf();
  738.   }
  739.   
  740. ! ifstream::ifstream(int fd)
  741.   {
  742. !     _strbuf = new filebuf(fd);
  743.   }
  744.   
  745. ! ifstream::ifstream(const char *name, int mode, int prot)
  746.   {
  747. !     _strbuf = new filebuf();
  748.       if (!rdbuf()->open(name, mode, prot))
  749.       set(ios::badbit);
  750.   }
  751.   
  752. ! ofstream::ofstream()
  753.   {
  754. !     _strbuf = new filebuf();
  755. ! }
  756. ! 
  757. ! ofstream::ofstream(int fd)
  758. ! {
  759. !     _strbuf = new filebuf(fd);
  760.   }
  761.   
  762. ! ofstream::ofstream(const char *name, int mode, int prot)
  763.   {
  764. !     _strbuf = new filebuf();
  765. !     if (!rdbuf()->open(name, mode, prot))
  766. !     set(ios::badbit);
  767.   }
  768.   
  769.   #if 0
  770. --- 22,55 ----
  771.   #pragma implementation
  772.   #endif
  773.   
  774. ! fstreambase::fstreambase()
  775.   {
  776. !     init(new filebuf());
  777.   }
  778.   
  779. ! fstreambase::fstreambase(int fd)
  780.   {
  781. !     init(new filebuf(fd));
  782.   }
  783.   
  784. ! fstreambase::fstreambase(const char *name, int mode, int prot)
  785.   {
  786. !     init(new filebuf());
  787.       if (!rdbuf()->open(name, mode, prot))
  788.       set(ios::badbit);
  789.   }
  790.   
  791. ! void fstreambase::open(const char *name, int mode, int prot)
  792.   {
  793. !     clear();
  794. !     if (!rdbuf()->open(name, mode, prot))
  795. !     set(ios::badbit);
  796.   }
  797.   
  798. ! void fstreambase::close()
  799.   {
  800. !     if (!rdbuf()->close())
  801. !     set(ios::failbit);
  802.   }
  803.   
  804.   #if 0
  805. ***************
  806. *** 67,119 ****
  807.       return "w";
  808.   }
  809.   #endif
  810. - 
  811. - void ifstream::open(const char *name, int mode, int prot)
  812. - {
  813. -     if (!rdbuf()->open(name, mode, prot))
  814. -     set(ios::badbit);
  815. - }
  816. - 
  817. - void ifstream::close()
  818. - {
  819. -     rdbuf()->close();
  820. - }
  821. - 
  822. - void ofstream::close()
  823. - {
  824. -     rdbuf()->close();
  825. - }
  826. - 
  827. - void ofstream::open(const char *name, int mode, int prot)
  828. - {
  829. -     if (!rdbuf()->open(name, mode, prot))
  830. -     set(ios::badbit);
  831. - }
  832. - 
  833. - fstream::fstream()
  834. - {
  835. -     _strbuf = new filebuf();
  836. - }
  837. - 
  838. - fstream::fstream(int fd)
  839. - {
  840. -     _strbuf = new filebuf(fd);
  841. - }
  842. - 
  843. - fstream::fstream(const char *name, int mode, int prot=0664)
  844. - {
  845. -     _strbuf = new filebuf();
  846. -     if (!rdbuf()->open(name, mode, prot))
  847. -     set(ios::badbit);
  848. - }
  849. - 
  850. - void fstream::open(const char *name, int mode, int prot=0664)
  851. - {
  852. -     if (!rdbuf()->open(name, mode, prot))
  853. -     set(ios::badbit);
  854. - }
  855. - 
  856. - void fstream::close()
  857. - {
  858. -     rdbuf()->close();
  859. - }
  860. --- 63,65 ----
  861. *** 1.3    1992/07/20 22:21:08
  862. --- igetline.cc    1993/02/22 17:06:33
  863. ***************
  864. *** 17,41 ****
  865.   
  866.   #include <iostream.h>
  867.   
  868. ! istream& istream::getline(char* buf, int len, char delim)
  869.   {
  870.       _gcount = 0;
  871.       if (ipfx1()) {
  872. !     long count = rdbuf()->sgetline(buf, len, delim, 0);
  873. !     _gcount = count;
  874. !     if (count <= 0 || count == len-1)
  875.           set(ios::failbit);
  876.       }
  877.       return *this;
  878.   }
  879.   
  880. ! istream& istream::get(char* buf, int len, char delim)
  881.   {
  882.       _gcount = 0;
  883.       if (ipfx1()) {
  884. !     long count = rdbuf()->sgetline(buf, len, delim, -1);
  885. !     if (count <= 0)
  886. !         set(ios::failbit);
  887.       else
  888.           _gcount = count;
  889.       }
  890. --- 17,52 ----
  891.   
  892.   #include <iostream.h>
  893.   
  894. ! istream& istream::getline(char* buf, _G_size_t len, char delim)
  895.   {
  896.       _gcount = 0;
  897.       if (ipfx1()) {
  898. !     streambuf *sb = rdbuf();
  899. !     long count = sb->sgetline(buf, len, delim, -1);
  900. !     if (count == len-1)
  901.           set(ios::failbit);
  902. +     else {
  903. +         int ch = sb->sbumpc();
  904. +         if (ch == EOF)
  905. +         set(ios::failbit|ios::eofbit);
  906. +         else if (ch == (unsigned char)delim)
  907. +         count++;
  908. +         else
  909. +         sb->sungetc(); // Leave delimiter unread.
  910. +     }
  911. +     _gcount = count;
  912.       }
  913.       return *this;
  914.   }
  915.   
  916. ! istream& istream::get(char* buf, _G_size_t len, char delim)
  917.   {
  918.       _gcount = 0;
  919.       if (ipfx1()) {
  920. !     streambuf *sbuf = rdbuf();
  921. !     long count = sbuf->sgetline(buf, len, delim, -1);
  922. !     if (count < 0 || (count == 0 && sbuf->sgetc() == EOF))
  923. !         set(ios::failbit|ios::eofbit);
  924.       else
  925.           _gcount = count;
  926.       }
  927. *** 1.1    1992/03/22 07:42:32
  928. --- indstrea.cc    1993/02/22 17:06:34
  929. ***************
  930. *** 35,51 ****
  931.       if (_delete_flags & ios::out)  delete put_stream();
  932.   }
  933.   
  934. ! int indirectbuf::sputn(const char* s, int n)
  935.   {
  936.       return put_stream()->sputn(s, n);
  937.   }
  938.   
  939. ! int indirectbuf::sgetn(char* s, int n)
  940.   {
  941.       return get_stream()->sgetn(s, n);
  942.   }
  943.   
  944. ! int indirectbuf::overflow(int c = EOF)
  945.   {
  946.       if (c == EOF)
  947.       return put_stream()->overflow(c);
  948. --- 35,51 ----
  949.       if (_delete_flags & ios::out)  delete put_stream();
  950.   }
  951.   
  952. ! _G_size_t indirectbuf::xsputn(const char* s, _G_size_t n)
  953.   {
  954.       return put_stream()->sputn(s, n);
  955.   }
  956.   
  957. ! _G_size_t indirectbuf::xsgetn(char* s, _G_size_t n)
  958.   {
  959.       return get_stream()->sgetn(s, n);
  960.   }
  961.   
  962. ! int indirectbuf::overflow(int c /* = EOF */)
  963.   {
  964.       if (c == EOF)
  965.       return put_stream()->overflow(c);
  966. ***************
  967. *** 105,113 ****
  968.   int indirectbuf::pbackfail(int c)
  969.   {
  970.       return get_stream()->sputbackc(c);
  971. - }
  972. - 
  973. - int indirectbuf::ungetfail()
  974. - {
  975. -     return get_stream()->sungetc();
  976.   }
  977. --- 105,108 ----
  978. *** 1.2    1992/07/20 22:21:08
  979. --- iodtoa.cc    1993/02/22 17:06:34
  980. ***************
  981. *** 275,281 ****
  982.   
  983.   #define Kmax 15
  984.   
  985. ! extern "C" double strtod(const char *s00, char **se);
  986.   extern "C" char *dtoa(double d, int mode, int ndigits,
  987.                           int *decpt, int *sign, char **rve);
  988.   
  989. --- 275,281 ----
  990.   
  991.   #define Kmax 15
  992.   
  993. ! extern "C" double _Xstrtod(const char *s00, char **se);
  994.   extern "C" char *dtoa(double d, int mode, int ndigits,
  995.                           int *decpt, int *sign, char **rve);
  996.   
  997. ***************
  998. *** 1123,1129 ****
  999.   #endif
  1000.   
  1001.    double
  1002. ! strtod
  1003.   #ifdef KR_headers
  1004.           (s00, se) CONST char *s00; char **se;
  1005.   #else
  1006. --- 1123,1129 ----
  1007.   #endif
  1008.   
  1009.    double
  1010. ! _Xstrtod
  1011.   #ifdef KR_headers
  1012.           (s00, se) CONST char *s00; char **se;
  1013.   #else
  1014. ***************
  1015. *** 2397,2403 ****
  1016.   #ifdef atarist
  1017.   double atof(const char *s)
  1018.   {
  1019. !     return strtod(s, (char **)NULL);
  1020.   }
  1021.   #endif
  1022.   
  1023. --- 2397,2403 ----
  1024.   #ifdef atarist
  1025.   double atof(const char *s)
  1026.   {
  1027. !     return _Xstrtod(s, (char **)NULL);
  1028.   }
  1029.   #endif
  1030.   
  1031. *** 1.8    1992/12/11 19:39:04
  1032. --- iostream.cc    1993/02/22 17:06:35
  1033. ***************
  1034. *** 1,5 ****
  1035.   //    This is part of the iostream library, providing input/output for C++.
  1036. ! //    Copyright (C) 1991 Per Bothner.
  1037.   //
  1038.   //    This library is free software; you can redistribute it and/or
  1039.   //    modify it under the terms of the GNU Library General Public
  1040. --- 1,5 ----
  1041.   //    This is part of the iostream library, providing input/output for C++.
  1042. ! //    Copyright (C) 1991, 1992 Per Bothner.
  1043.   //
  1044.   //    This library is free software; you can redistribute it and/or
  1045.   //    modify it under the terms of the GNU Library General Public
  1046. ***************
  1047. *** 23,28 ****
  1048. --- 23,29 ----
  1049.   #include <iostream.h>
  1050.   #include <stdio.h>  /* Needed for sprintf */
  1051.   #include <ctype.h>
  1052. + #include <limits.h>
  1053.   #include <floatio.h>
  1054.   
  1055.   #define    BUF        (MAXEXP+MAXFRACT+1)    /* + decimal point */
  1056. ***************
  1057. *** 29,36 ****
  1058.   
  1059.   //#define isspace(ch) ((ch)==' ' || (ch)=='\t' || (ch)=='\n')
  1060.   
  1061. - extern backupbuf not_open_filebuf;
  1062. - 
  1063.   istream::istream(streambuf *sb, ostream* tied) : ios(sb, tied)
  1064.   {
  1065.       _flags |= ios::dont_close;
  1066. --- 30,35 ----
  1067. ***************
  1068. *** 57,64 ****
  1069.       return *this;
  1070.   }
  1071.   
  1072. ! istream& istream::ignore(int n=1, int delim = EOF)
  1073.   {
  1074.       if (ipfx1()) {
  1075.       register streambuf* sb = _strbuf;
  1076.       if (delim == EOF) {
  1077. --- 56,64 ----
  1078.       return *this;
  1079.   }
  1080.   
  1081. ! istream& istream::ignore(_G_size_t n1 /* = 1 */, int delim /* = EOF */)
  1082.   {
  1083. +     long n = n1;
  1084.       if (ipfx1()) {
  1085.       register streambuf* sb = _strbuf;
  1086.       if (delim == EOF) {
  1087. ***************
  1088. *** 85,91 ****
  1089.       return *this;
  1090.   }
  1091.   
  1092. ! istream& istream::read(char *s, size_t n)
  1093.   {
  1094.       if (ipfx1()) {
  1095.       _gcount = _strbuf->sgetn(s, n);
  1096. --- 85,91 ----
  1097.       return *this;
  1098.   }
  1099.   
  1100. ! istream& istream::read(char *s, _G_size_t n)
  1101.   {
  1102.       if (ipfx1()) {
  1103.       _gcount = _strbuf->sgetn(s, n);
  1104. ***************
  1105. *** 124,130 ****
  1106.       if (ipfx0()) {
  1107.       va_list ap;
  1108.       va_start(ap, format);
  1109. !     _strbuf->vscan(format, ap, &_state);
  1110.       va_end(ap);
  1111.       }
  1112.       return *this;
  1113. --- 124,130 ----
  1114.       if (ipfx0()) {
  1115.       va_list ap;
  1116.       va_start(ap, format);
  1117. !     _strbuf->vscan(format, ap, this);
  1118.       va_end(ap);
  1119.       }
  1120.       return *this;
  1121. ***************
  1122. *** 133,168 ****
  1123.   istream& istream::vscan(const char *format, _G_va_list args)
  1124.   {
  1125.       if (ipfx0())
  1126. !     _strbuf->vscan(format, args, &_state);
  1127.       return *this;
  1128.   }
  1129.   
  1130. ! istream& operator>>(istream& is, char& c)
  1131.   {
  1132. !     if (is.ipfx0()) {
  1133. !     int ch = is._strbuf->sbumpc();
  1134.       if (ch == EOF)
  1135. !         is.set(ios::eofbit|ios::failbit);
  1136.       else
  1137.           c = (char)ch;
  1138.       }
  1139. !     return is;
  1140.   }
  1141.   
  1142. ! istream& operator>>(istream& is, char* ptr)
  1143.   {
  1144. !     if (is.ipfx0()) {
  1145. !     register streambuf* sb = is._strbuf;
  1146.       int ch = sb->sbumpc();
  1147.       if (ch == EOF)
  1148. !         is.set(ios::eofbit|ios::failbit);
  1149.       else {
  1150. !         int w = is.width(0);
  1151. !         *ptr++ = ch;
  1152.           for (;;) {
  1153.           ch = sb->sbumpc();
  1154.           if (ch == EOF) {
  1155. !             is.set(ios::eofbit|ios::failbit);
  1156.               break;
  1157.           }
  1158.           else if (isspace(ch)) {
  1159. --- 133,168 ----
  1160.   istream& istream::vscan(const char *format, _G_va_list args)
  1161.   {
  1162.       if (ipfx0())
  1163. !     _strbuf->vscan(format, args, this);
  1164.       return *this;
  1165.   }
  1166.   
  1167. ! istream& istream::operator>>(char& c)
  1168.   {
  1169. !     if (ipfx0()) {
  1170. !     int ch = _strbuf->sbumpc();
  1171.       if (ch == EOF)
  1172. !         set(ios::eofbit|ios::failbit);
  1173.       else
  1174.           c = (char)ch;
  1175.       }
  1176. !     return *this;
  1177.   }
  1178.   
  1179. ! istream& istream::operator>>(char* ptr)
  1180.   {
  1181. !     if (ipfx0()) {
  1182. !     register streambuf* sb = _strbuf;
  1183.       int ch = sb->sbumpc();
  1184.       if (ch == EOF)
  1185. !         set(ios::eofbit|ios::failbit);
  1186.       else {
  1187. !         int w = width(0);
  1188. !         sb->sputbackc(ch);
  1189.           for (;;) {
  1190.           ch = sb->sbumpc();
  1191.           if (ch == EOF) {
  1192. !             set(ios::eofbit);
  1193.               break;
  1194.           }
  1195.           else if (isspace(ch)) {
  1196. ***************
  1197. *** 170,176 ****
  1198.               break;
  1199.           }
  1200.           else if (w == 1) {
  1201. !             is.set(ios::failbit);
  1202.               sb->sputbackc(ch);
  1203.               break;
  1204.           }
  1205. --- 170,176 ----
  1206.               break;
  1207.           }
  1208.           else if (w == 1) {
  1209. !             set(ios::failbit);
  1210.               sb->sputbackc(ch);
  1211.               break;
  1212.           }
  1213. ***************
  1214. *** 180,189 ****
  1215.       }
  1216.       }
  1217.       *ptr = '\0';
  1218. !     return is;
  1219.   }
  1220.   
  1221. ! static int read_int(istream& stream, unsigned long& val, int& neg)
  1222.   {
  1223.       if (!stream.ipfx0())
  1224.       return 0;
  1225. --- 180,195 ----
  1226.       }
  1227.       }
  1228.       *ptr = '\0';
  1229. !     return *this;
  1230.   }
  1231.   
  1232. ! #if defined(__GNUC__) && (!defined(atarist))
  1233. ! #define LONGEST long long
  1234. ! #else
  1235. ! #define LONGEST long
  1236. ! #endif
  1237. ! 
  1238. ! static int read_int(istream& stream, unsigned LONGEST& val, int& neg)
  1239.   {
  1240.       if (!stream.ipfx0())
  1241.       return 0;
  1242. ***************
  1243. *** 202,208 ****
  1244.       ch = skip_ws(sb);
  1245.       }
  1246.       if (ch == EOF) goto eof_fail;
  1247. !     if (!(stream.flags() & (ios::hex|ios::dec|ios::oct))) {
  1248.       if (ch == '0') {
  1249.           ch = sb->sbumpc();
  1250.           if (ch == EOF) {
  1251. --- 208,214 ----
  1252.       ch = skip_ws(sb);
  1253.       }
  1254.       if (ch == EOF) goto eof_fail;
  1255. !     if (!(stream.flags() & ios::basefield)) {
  1256.       if (ch == '0') {
  1257.           ch = sb->sbumpc();
  1258.           if (ch == EOF) {
  1259. ***************
  1260. *** 221,229 ****
  1261.           }
  1262.       }
  1263.       }
  1264. !     else if (stream.flags() & ios::hex)
  1265.       base = 16;
  1266. !     else if (stream.flags() & ios::oct)
  1267.       base = 8;
  1268.       val = 0;
  1269.       for (;;) {
  1270. --- 227,235 ----
  1271.           }
  1272.       }
  1273.       }
  1274. !     else if ((stream.flags() & ios::basefield) == ios::hex)
  1275.       base = 16;
  1276. !     else if ((stream.flags() & ios::basefield) == ios::oct)
  1277.       base = 8;
  1278.       val = 0;
  1279.       for (;;) {
  1280. ***************
  1281. *** 259,272 ****
  1282.   }
  1283.   
  1284.   #define READ_INT(TYPE) \
  1285. ! istream& operator>>(istream& is, TYPE& i)\
  1286.   {\
  1287. !     unsigned long val; int neg;\
  1288. !     if (read_int(is, val, neg)) {\
  1289.       if (neg) val = -val;\
  1290.       i = (TYPE)val;\
  1291.       }\
  1292. !     return is;\
  1293.   }
  1294.   
  1295.   READ_INT(short)
  1296. --- 265,278 ----
  1297.   }
  1298.   
  1299.   #define READ_INT(TYPE) \
  1300. ! istream& istream::operator>>(TYPE& i)\
  1301.   {\
  1302. !     unsigned LONGEST val; int neg;\
  1303. !     if (read_int(*this, val, neg)) {\
  1304.       if (neg) val = -val;\
  1305.       i = (TYPE)val;\
  1306.       }\
  1307. !     return *this;\
  1308.   }
  1309.   
  1310.   READ_INT(short)
  1311. ***************
  1312. *** 275,365 ****
  1313.   READ_INT(unsigned int)
  1314.   READ_INT(long)
  1315.   READ_INT(unsigned long)
  1316.   
  1317. ! istream& operator>>(istream& is, double& x)
  1318.   {
  1319. !     if (is.ipfx0()) {
  1320. !     is.scan("%lg", &x);
  1321. !     }
  1322. !     return is;
  1323.   }
  1324. ! istream& operator>>(istream& is, float& x)
  1325.   {
  1326. !     if (is.ipfx0()) {
  1327. !     is.scan("%g", &x);
  1328. !     }
  1329. !     return is;
  1330.   }
  1331.   
  1332. ! istream& operator>>(istream& is, register streambuf* sbuf)
  1333.   {
  1334. !     if (is.ipfx0()) {
  1335. !     register streambuf* inbuf = is.rdbuf();
  1336.       // FIXME: Should optimize!
  1337.       for (;;) {
  1338.           register int ch = inbuf->sbumpc();
  1339.           if (ch == EOF) {
  1340. !         is.set(ios::eofbit);
  1341.           break;
  1342.           }
  1343.           if (sbuf->sputc(ch) == EOF) {
  1344. !         is.set(ios::failbit);
  1345.           break;
  1346.           }
  1347.       }
  1348.       }
  1349. !     return is;
  1350.   }
  1351.   
  1352. ! ostream& operator<<(ostream& os, char c)
  1353.   {
  1354. !     if (os.opfx()) {
  1355. !     int w = os.width(0);
  1356. !     char fill_char = os.fill();
  1357.       register int padding = w > 0 ? w - 1 : 0;
  1358. !     register streambuf *sb = os._strbuf;
  1359. !     if (!(os.flags() & ios::left)) // Default adjustment.
  1360.           while (--padding >= 0) sb->sputc(fill_char);
  1361.       sb->sputc(c);
  1362. !     if (os.flags() & ios::left) // Left adjustment.
  1363.           while (--padding >= 0) sb->sputc(fill_char);
  1364. !     os.osfx();
  1365.       }
  1366. !     return os;
  1367.   }
  1368.   
  1369. ! void write_int(ostream& stream, unsigned long val, int neg)
  1370.   {
  1371. !     char buf[10 + sizeof(unsigned long) * 3];
  1372.       char *show_base = "";
  1373.       int show_base_len = 0;
  1374. !     if ((stream.flags() & (ios::oct|ios::hex)) == 0) // Decimal
  1375. !     sprintf(buf, "%lu", val);
  1376. !     else if (stream.flags() & ios::oct) { // Oct
  1377. !     sprintf(buf, "%lo", val);
  1378. !     if (stream.flags() & ios::showbase)
  1379.           show_base = "0", show_base_len = 1;
  1380.       }
  1381. !     else if (stream.flags() & ios::uppercase) {// Hex
  1382. !     sprintf(buf, "%lX", val);
  1383. !     if (stream.flags() & ios::showbase)
  1384. !         show_base = "0X", show_base_len = 2;
  1385. !     }
  1386. !     else { // Hex
  1387. !     sprintf(buf, "%lx", val);
  1388. !     if (stream.flags() & ios::showbase)
  1389. !         show_base = "0x", show_base_len = 2;
  1390.       }
  1391. !     int buf_len = strlen(buf);
  1392.       int w = stream.width(0);
  1393. -     int show_pos = 0;
  1394.   
  1395.       // Calculate padding.
  1396. !     int len = buf_len;
  1397. !     if (neg) len++;
  1398. !     else if (val != 0 && (stream.flags() & ios::showpos)) len++, show_pos=1;
  1399.       len += show_base_len;
  1400. !     int padding = len > w ? 0 : w - len;
  1401.   
  1402.       // Do actual output.
  1403.       register streambuf* sbuf = stream.rdbuf();
  1404. --- 281,407 ----
  1405.   READ_INT(unsigned int)
  1406.   READ_INT(long)
  1407.   READ_INT(unsigned long)
  1408. + #ifdef __GNUG__
  1409. + READ_INT(long long)
  1410. + READ_INT(unsigned long long)
  1411. + #endif
  1412.   
  1413. ! istream& istream::operator>>(double& x)
  1414.   {
  1415. !     if (ipfx0())
  1416. !     scan("%lg", &x);
  1417. !     return *this;
  1418.   }
  1419. ! 
  1420. ! istream& istream::operator>>(float& x)
  1421.   {
  1422. !     if (ipfx0())
  1423. !     scan("%g", &x);
  1424. !     return *this;
  1425.   }
  1426.   
  1427. ! istream& istream::operator>>(register streambuf* sbuf)
  1428.   {
  1429. !     if (ipfx0()) {
  1430. !     register streambuf* inbuf = rdbuf();
  1431.       // FIXME: Should optimize!
  1432.       for (;;) {
  1433.           register int ch = inbuf->sbumpc();
  1434.           if (ch == EOF) {
  1435. !         set(ios::eofbit);
  1436.           break;
  1437.           }
  1438.           if (sbuf->sputc(ch) == EOF) {
  1439. !         set(ios::failbit);
  1440.           break;
  1441.           }
  1442.       }
  1443.       }
  1444. !     return *this;
  1445.   }
  1446.   
  1447. ! ostream& ostream::operator<<(char c)
  1448.   {
  1449. !     if (opfx()) {
  1450. !     int w = width(0);
  1451. !     char fill_char = fill();
  1452.       register int padding = w > 0 ? w - 1 : 0;
  1453. !     register streambuf *sb = _strbuf;
  1454. !     if (!(flags() & ios::left)) // Default adjustment.
  1455.           while (--padding >= 0) sb->sputc(fill_char);
  1456.       sb->sputc(c);
  1457. !     if (flags() & ios::left) // Left adjustment.
  1458.           while (--padding >= 0) sb->sputc(fill_char);
  1459. !     osfx();
  1460.       }
  1461. !     return *this;
  1462.   }
  1463.   
  1464. ! /* Write VAL on STREAM.
  1465. !    If SIGN<0, val is the absolute value of a negative number.
  1466. !    If SIGN>0, val is a signed non-negative number.
  1467. !    If SIGN==0, val is unsigned. */
  1468. ! 
  1469. ! static void write_int(ostream& stream, unsigned LONGEST val, int sign)
  1470.   {
  1471. ! #define WRITE_BUF_SIZE (10 + sizeof(unsigned LONGEST) * 3)
  1472. !     char buf[WRITE_BUF_SIZE];
  1473. !     register char *buf_ptr = buf+WRITE_BUF_SIZE; // End of buf.
  1474.       char *show_base = "";
  1475.       int show_base_len = 0;
  1476. !     int show_pos = 0; // If 1, print a '+'.
  1477. ! 
  1478. !     // Now do the actual conversion, placing the result at the *end* of buf.
  1479. !     // Note that we use separate code for decimal, octal, and hex,
  1480. !     // so we can divide by optimizable constants.
  1481. !     if ((stream.flags() & ios::basefield) == ios::oct) { // Octal
  1482. !     if ((stream.flags() & ios::showbase) && (val != 0))
  1483.           show_base = "0", show_base_len = 1;
  1484. +     do {
  1485. +         *--buf_ptr = (val & 7) + '0';
  1486. +         val = val >> 3;
  1487. +     } while (val != 0);
  1488. +     }
  1489. +     else if ((stream.flags() & ios::basefield) == ios::hex) { // Hex
  1490. +     char *xdigs = (stream.flags() & ios::uppercase) ? "0123456789ABCDEF0X"
  1491. +         : "0123456789abcdef0x";
  1492. +     do {
  1493. +         *--buf_ptr = xdigs[val & 15];
  1494. +         val = val >> 4;
  1495. +     } while (val != 0);
  1496. +     if (stream.flags() & ios::showbase) {
  1497. +         show_base = xdigs + 16; // Either "0X" or "0x".
  1498. +         show_base_len = 2;
  1499. +     }
  1500.       }
  1501. !     else { // Decimal
  1502. !     if (val != 0 && sign > 0 && (stream.flags() & ios::showpos))
  1503. !         show_pos=1;
  1504. ! #ifdef __GNUC__
  1505. !     // Optimization:  Only use long long when we need to.
  1506. !     while (val > UINT_MAX) {
  1507. !         *--buf_ptr = (val % 10) + '0';
  1508. !         val /= 10;
  1509. !     }
  1510. !     // Use more efficient (int) arithmetic for the rest.
  1511. !     register unsigned int ival = (unsigned int)val;
  1512. ! #else
  1513. !     register unsigned LONGEST ival = val;
  1514. ! #endif
  1515. !     do {
  1516. !         *--buf_ptr = (ival % 10) + '0';
  1517. !         ival /= 10;
  1518. !     } while (ival != 0);
  1519.       }
  1520. ! 
  1521. !     _G_size_t buf_len = buf+WRITE_BUF_SIZE - buf_ptr;
  1522.       int w = stream.width(0);
  1523.   
  1524.       // Calculate padding.
  1525. !     _G_size_t len = buf_len+show_pos;
  1526. !     if (sign < 0) len++;
  1527.       len += show_base_len;
  1528. !     _G_size_t padding = len > w ? 0 : w - len;
  1529.   
  1530.       // Do actual output.
  1531.       register streambuf* sbuf = stream.rdbuf();
  1532. ***************
  1533. *** 370,450 ****
  1534.       && pad_kind != (ios::fmtflags)ios::left
  1535.       && pad_kind != (ios::fmtflags)ios::internal) // Default (right) adjust.
  1536.       sbuf->padn(fill_char, padding);
  1537. !     if (neg) sbuf->sputc('-');
  1538.       else if (show_pos) sbuf->sputc('+');
  1539.       if (show_base_len)
  1540.       sbuf->sputn(show_base, show_base_len);
  1541.       if (pad_kind == (ios::fmtflags)ios::internal && padding > 0)
  1542.       sbuf->padn(fill_char, padding);
  1543. !     sbuf->sputn(buf, buf_len);
  1544.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  1545.       sbuf->padn(fill_char, padding);
  1546.       stream.osfx();
  1547.   }
  1548.   
  1549. ! ostream& operator<<(ostream& os, int n)
  1550.   {
  1551. !     if (os.opfx()) {
  1552. !     int neg = 0;
  1553. !     if (n < 0 && (os.flags() & (ios::oct|ios::hex)) == 0)
  1554. !         n = -n, neg = 1;
  1555. !     write_int(os, n, neg);
  1556.       }
  1557. !     return os;
  1558.   }
  1559.   
  1560. ! ostream& operator<<(ostream& os, long n)
  1561.   {
  1562. !     if (os.opfx()) {
  1563. !     int neg = 0;
  1564. !     if (n < 0 && (os.flags() & (ios::oct|ios::hex)) == 0)
  1565. !         n = -n, neg = 1;
  1566. !     write_int(os, n, neg);
  1567.       }
  1568. !     return os;
  1569.   }
  1570.   
  1571. ! ostream& operator<<(ostream& os, unsigned int n)
  1572.   {
  1573. !     if (os.opfx())
  1574. !     write_int(os, n, 0);
  1575. !     return os;
  1576.   }
  1577.   
  1578. ! ostream& operator<<(ostream& os, unsigned long n)
  1579.   {
  1580. !     if (os.opfx())
  1581. !     write_int(os, n, 0);
  1582. !     return os;
  1583.   }
  1584.   
  1585. ! ostream& operator<<(ostream& os, float n)
  1586.   {
  1587. !     return os << (double)n;
  1588.   }
  1589.   
  1590. ! ostream& operator<<(ostream& os, double n)
  1591.   {
  1592. !     if (os.opfx()) {
  1593.       // Uses __cvt_double (renamed from static cvt), in Chris Torek's
  1594.       // stdio implementation.  The setup code uses the same logic
  1595.       // as in __vsbprintf.C (also based on Torek's code).
  1596.       int format_char;
  1597.   #if 0
  1598. !     if (os.flags() ios::showpos) sign = '+';
  1599.   #endif
  1600. !     if (os.flags() & ios::fixed)
  1601.           format_char = 'f';
  1602. !     else if (os.flags() & ios::scientific)
  1603. !         format_char = os.flags() & ios::uppercase ? 'E' : 'e';
  1604.       else
  1605. !         format_char = os.flags() & ios::uppercase ? 'G' : 'g';
  1606.   
  1607.       int fpprec = 0; // 'Extra' (suppressed) floating precision.
  1608. !     int prec = os.precision();
  1609.       if (prec < 0) prec = 6; // default.
  1610.       else if (prec > MAXFRACT) {
  1611. !         if (os.flags() & (ios::fixed|ios::scientific) & ios::showpos)
  1612.           fpprec = prec - MAXFRACT;
  1613.           prec = MAXFRACT;
  1614.       }
  1615. --- 412,509 ----
  1616.       && pad_kind != (ios::fmtflags)ios::left
  1617.       && pad_kind != (ios::fmtflags)ios::internal) // Default (right) adjust.
  1618.       sbuf->padn(fill_char, padding);
  1619. !     if (sign < 0) sbuf->sputc('-');
  1620.       else if (show_pos) sbuf->sputc('+');
  1621.       if (show_base_len)
  1622.       sbuf->sputn(show_base, show_base_len);
  1623.       if (pad_kind == (ios::fmtflags)ios::internal && padding > 0)
  1624.       sbuf->padn(fill_char, padding);
  1625. !     sbuf->sputn(buf_ptr, buf_len);
  1626.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  1627.       sbuf->padn(fill_char, padding);
  1628.       stream.osfx();
  1629.   }
  1630.   
  1631. ! ostream& ostream::operator<<(int n)
  1632.   {
  1633. !     if (opfx()) {
  1634. !     int sign = 1;
  1635. !     if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
  1636. !         n = -n, sign = -1;
  1637. !     write_int(*this, n, sign);
  1638.       }
  1639. !     return *this;
  1640. ! }
  1641. ! 
  1642. ! ostream& ostream::operator<<(unsigned int n)
  1643. ! {
  1644. !     if (opfx())
  1645. !     write_int(*this, n, 0);
  1646. !     return *this;
  1647.   }
  1648.   
  1649. ! 
  1650. ! ostream& ostream::operator<<(long n)
  1651.   {
  1652. !     if (opfx()) {
  1653. !     int sign = 1;
  1654. !     if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
  1655. !         n = -n, sign = -1;
  1656. !     write_int(*this, n, sign);
  1657.       }
  1658. !     return *this;
  1659.   }
  1660.   
  1661. ! ostream& ostream::operator<<(unsigned long n)
  1662.   {
  1663. !     if (opfx())
  1664. !     write_int(*this, n, 0);
  1665. !     return *this;
  1666.   }
  1667.   
  1668. ! #ifdef __GNUG__
  1669. ! ostream& ostream::operator<<(long long n)
  1670.   {
  1671. !     if (opfx()) {
  1672. !     int sign = 1;
  1673. !     if (n < 0 && (flags() & (ios::oct|ios::hex)) == 0)
  1674. !         n = -n, sign = -1;
  1675. !     write_int(*this, n, sign);
  1676. !     }
  1677. !     return *this;
  1678.   }
  1679.   
  1680. ! 
  1681. ! ostream& ostream::operator<<(unsigned long long n)
  1682.   {
  1683. !     if (opfx())
  1684. !     write_int(*this, n, 0);
  1685. !     return *this;
  1686.   }
  1687. + #endif /*__GNUG__*/
  1688.   
  1689. ! ostream& ostream::operator<<(double n)
  1690.   {
  1691. !     if (opfx()) {
  1692.       // Uses __cvt_double (renamed from static cvt), in Chris Torek's
  1693.       // stdio implementation.  The setup code uses the same logic
  1694.       // as in __vsbprintf.C (also based on Torek's code).
  1695.       int format_char;
  1696.   #if 0
  1697. !     if (flags() ios::showpos) sign = '+';
  1698.   #endif
  1699. !     if ((flags() & ios::floatfield) == ios::fixed)
  1700.           format_char = 'f';
  1701. !     else if ((flags() & ios::floatfield) == ios::scientific)
  1702. !         format_char = flags() & ios::uppercase ? 'E' : 'e';
  1703.       else
  1704. !         format_char = flags() & ios::uppercase ? 'G' : 'g';
  1705.   
  1706.       int fpprec = 0; // 'Extra' (suppressed) floating precision.
  1707. !     int prec = precision();
  1708.       if (prec < 0) prec = 6; // default.
  1709.       else if (prec > MAXFRACT) {
  1710. !         if (flags() & (ios::fixed|ios::scientific) & ios::showpos)
  1711.           fpprec = prec - MAXFRACT;
  1712.           prec = MAXFRACT;
  1713.       }
  1714. ***************
  1715. *** 451,459 ****
  1716.   
  1717.       // Do actual conversion.
  1718.   #ifdef USE_DTOA
  1719. !     if (__outfloat(n, os.rdbuf(), format_char, os.width(0),
  1720. !                os.precision(), os.flags(), 0, os.fill()) < 0)
  1721. !         os.set(ios::badbit|ios::failbit); // ??
  1722.   #else
  1723.       int negative;
  1724.       char buf[BUF];
  1725. --- 510,518 ----
  1726.   
  1727.       // Do actual conversion.
  1728.   #ifdef USE_DTOA
  1729. !     if (__outfloat(n, rdbuf(), format_char, width(0),
  1730. !                precision(), flags(), 0, fill()) < 0)
  1731. !         set(ios::badbit|ios::failbit); // ??
  1732.   #else
  1733.       int negative;
  1734.       char buf[BUF];
  1735. ***************
  1736. *** 460,467 ****
  1737.       int sign = '\0';
  1738.       char *cp = buf;
  1739.       *cp = 0;
  1740. !     int size = __cvt_double(n, os.precision(),
  1741. !                 os.flags() & ios::showpoint ? 0x80 : 0,
  1742.                   &negative,
  1743.                   format_char, cp, buf + sizeof(buf));
  1744.       if (negative) sign = '-';
  1745. --- 519,526 ----
  1746.       int sign = '\0';
  1747.       char *cp = buf;
  1748.       *cp = 0;
  1749. !     int size = __cvt_double(n, precision(),
  1750. !                 flags() & ios::showpoint ? 0x80 : 0,
  1751.                   &negative,
  1752.                   format_char, cp, buf + sizeof(buf));
  1753.       if (negative) sign = '-';
  1754. ***************
  1755. *** 472,487 ****
  1756.       int fieldsize = size + fpprec;
  1757.       if (sign) fieldsize++;
  1758.       int padding = 0;
  1759. !     int w = os.width(0);
  1760.       if (fieldsize < w)
  1761.           padding = w - fieldsize;
  1762.   
  1763.       // Do actual output.
  1764. !     register streambuf* sbuf = os.rdbuf();
  1765.       register i;
  1766. !     char fill_char = os.fill();
  1767.       ios::fmtflags pad_kind =
  1768. !         os.flags() & (ios::left|ios::right|ios::internal);
  1769.       if (pad_kind != (ios::fmtflags)ios::left // Default (right) adjust.
  1770.           && pad_kind != (ios::fmtflags)ios::internal)
  1771.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1772. --- 531,546 ----
  1773.       int fieldsize = size + fpprec;
  1774.       if (sign) fieldsize++;
  1775.       int padding = 0;
  1776. !     int w = width(0);
  1777.       if (fieldsize < w)
  1778.           padding = w - fieldsize;
  1779.   
  1780.       // Do actual output.
  1781. !     register streambuf* sbuf = rdbuf();
  1782.       register i;
  1783. !     char fill_char = fill();
  1784.       ios::fmtflags pad_kind =
  1785. !         flags() & (ios::left|ios::right|ios::internal);
  1786.       if (pad_kind != (ios::fmtflags)ios::left // Default (right) adjust.
  1787.           && pad_kind != (ios::fmtflags)ios::internal)
  1788.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1789. ***************
  1790. *** 497,550 ****
  1791.       if (pad_kind == (ios::fmtflags)ios::left) // Left adjustment
  1792.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1793.   #endif
  1794. !     os.osfx();
  1795.       }
  1796. !     return os;
  1797.   }
  1798.   
  1799. ! ostream& operator<<(ostream& stream, const char *s)
  1800.   {
  1801. !     if (stream.opfx()) {
  1802. !     size_t len = strlen(s);
  1803. !     int w = stream.width(0);
  1804. !     char fill_char = stream.fill();
  1805. !     register streambuf *sbuf = stream.rdbuf();
  1806.       register int padding = w > len ? w - len : 0;
  1807. !     if (!(stream.flags() & ios::left)) // Default adjustment.
  1808.           while (--padding >= 0) sbuf->sputc(fill_char);
  1809.       sbuf->sputn(s, len);
  1810. !     if (stream.flags() & ios::left) // Left adjustment.
  1811.           while (--padding >= 0) sbuf->sputc(fill_char);
  1812. !     stream.osfx();
  1813.       }
  1814. !     return stream;
  1815.   }
  1816.   
  1817. ! ostream& operator<<(ostream& os, void *p)
  1818.   {
  1819. !     if (os.opfx()) {
  1820. !     os.form("%p", p);
  1821. !     os.osfx();
  1822.       }
  1823. !     return os;
  1824.   }
  1825.   
  1826. ! ostream& operator<<(ostream& os, register streambuf* sbuf)
  1827.   {
  1828. !     if (os.opfx()) {
  1829. !     register streambuf* outbuf = os.rdbuf();
  1830.       // FIXME: Should optimize!
  1831.       for (;;) {
  1832.           register int ch = sbuf->sbumpc();
  1833.           if (ch == EOF) break;
  1834.           if (outbuf->sputc(ch) == EOF) {
  1835. !         os.set(ios::badbit);
  1836.           break;
  1837.           }
  1838.       }
  1839. !     os.osfx();
  1840.       }
  1841. !     return os;
  1842.   }
  1843.   
  1844.   ostream::ostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  1845. --- 556,611 ----
  1846.       if (pad_kind == (ios::fmtflags)ios::left) // Left adjustment
  1847.           for (i = padding; --i >= 0; ) sbuf->sputc(fill_char);
  1848.   #endif
  1849. !     osfx();
  1850.       }
  1851. !     return *this;
  1852.   }
  1853.   
  1854. ! ostream& ostream::operator<<(const char *s)
  1855.   {
  1856. !     if (opfx()) {
  1857. !     if (s == NULL)
  1858. !         s = "(null)";
  1859. !     _G_size_t len = strlen(s);
  1860. !     int w = width(0);
  1861. !     char fill_char = fill();
  1862. !     register streambuf *sbuf = rdbuf();
  1863.       register int padding = w > len ? w - len : 0;
  1864. !     if (!(flags() & ios::left)) // Default adjustment.
  1865.           while (--padding >= 0) sbuf->sputc(fill_char);
  1866.       sbuf->sputn(s, len);
  1867. !     if (flags() & ios::left) // Left adjustment.
  1868.           while (--padding >= 0) sbuf->sputc(fill_char);
  1869. !     osfx();
  1870.       }
  1871. !     return *this;
  1872.   }
  1873.   
  1874. ! ostream& ostream::operator<<(void *p)
  1875.   {
  1876. !     if (opfx()) {
  1877. !     form("%p", p);
  1878. !     osfx();
  1879.       }
  1880. !     return *this;
  1881.   }
  1882.   
  1883. ! ostream& ostream::operator<<(register streambuf* sbuf)
  1884.   {
  1885. !     if (opfx()) {
  1886. !     register streambuf* outbuf = rdbuf();
  1887.       // FIXME: Should optimize!
  1888.       for (;;) {
  1889.           register int ch = sbuf->sbumpc();
  1890.           if (ch == EOF) break;
  1891.           if (outbuf->sputc(ch) == EOF) {
  1892. !         set(ios::badbit);
  1893.           break;
  1894.           }
  1895.       }
  1896. !     osfx();
  1897.       }
  1898. !     return *this;
  1899.   }
  1900.   
  1901.   ostream::ostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  1902. ***************
  1903. *** 647,653 ****
  1904.       return flush(outs.put('\n'));
  1905.   }
  1906.   
  1907. ! ostream& ostream::write(const char *s, size_t n)
  1908.   {
  1909.       if (opfx()) {
  1910.       if (_strbuf->sputn(s, n) != n)
  1911. --- 708,714 ----
  1912.       return flush(outs.put('\n'));
  1913.   }
  1914.   
  1915. ! ostream& ostream::write(const char *s, _G_size_t n)
  1916.   {
  1917.       if (opfx()) {
  1918.       if (_strbuf->sputn(s, n) != n)
  1919. ***************
  1920. *** 666,676 ****
  1921.       }
  1922.   }
  1923.   
  1924. - const unsigned long ios::basefield = ios::hex|ios::oct|ios::dec;
  1925. - const unsigned long ios::floatfield = ios::scientific|ios::fixed;
  1926. - const unsigned long ios::adjustfield =
  1927. -     ios::left|ios::right|ios::internal;
  1928. - 
  1929.   iostream::iostream(streambuf* sb, ostream* tied) : ios(sb, tied)
  1930.   {
  1931.       _flags |= ios::dont_close;
  1932. --- 727,732 ----
  1933. ***************
  1934. *** 677,701 ****
  1935.       _gcount = 0;
  1936.   }
  1937.   
  1938. - ostream& iostream::form(const char *format ...) // Copy of ostream::form.
  1939. - {
  1940. -     va_list ap;
  1941. -     va_start(ap, format);
  1942. -     _strbuf->vform(format, ap);
  1943. -     va_end(ap);
  1944. -     return *(ostream*)this;
  1945. - }
  1946. - istream& iostream::scan(const char *format ...) // Copy of istream::scan
  1947. - {
  1948. -     if (ipfx0()) {
  1949. -     va_list ap;
  1950. -     va_start(ap, format);
  1951. -     _strbuf->vscan(format, ap, &_state);
  1952. -     va_end(ap);
  1953. -     }
  1954. -     return *(istream *)this;
  1955. - }
  1956. - 
  1957.   // NOTE: extension for compatibility with old libg++.
  1958.   // Not really compatible with fistream::close().
  1959.   #ifdef _STREAM_COMPAT
  1960. --- 733,738 ----
  1961. ***************
  1962. *** 705,717 ****
  1963.       delete _strbuf;
  1964.       else if (_strbuf->_flags & _S_IS_FILEBUF)
  1965.       ((struct filebuf*)_strbuf)->close();
  1966. !     else if (_strbuf != ¬_open_filebuf)
  1967.       _strbuf->sync();
  1968.       _flags |= ios::dont_close;
  1969. !     _strbuf = ¬_open_filebuf;
  1970.   }
  1971.   
  1972. ! int istream::skip(int i)
  1973.   {
  1974.       int old = (_flags & ios::skipws) != 0;
  1975.       if (i)
  1976. --- 742,755 ----
  1977.       delete _strbuf;
  1978.       else if (_strbuf->_flags & _S_IS_FILEBUF)
  1979.       ((struct filebuf*)_strbuf)->close();
  1980. !     else if (_strbuf != NULL)
  1981.       _strbuf->sync();
  1982.       _flags |= ios::dont_close;
  1983. !     _strbuf = NULL;
  1984. !     _state = badbit;
  1985.   }
  1986.   
  1987. ! int istream::skip(_G_size_t i)
  1988.   {
  1989.       int old = (_flags & ios::skipws) != 0;
  1990.       if (i)
  1991. *** 1.4    1992/06/03 02:12:17
  1992. --- makebuf.cc    1993/02/22 17:06:35
  1993. ***************
  1994. *** 27,33 ****
  1995.   #include <sys/stat.h>
  1996.   
  1997.   #ifdef atarist
  1998. ! extern "C" extern unsigned long __DEFAULT_BUFSIZ__;
  1999.   #undef BUFSIZ
  2000.   #define BUFSIZ __DEFAULT_BUFSIZ__
  2001.   #endif
  2002. --- 27,33 ----
  2003.   #include <sys/stat.h>
  2004.   
  2005.   #ifdef atarist
  2006. ! extern "C" unsigned long __DEFAULT_BUFSIZ__;
  2007.   #undef BUFSIZ
  2008.   #define BUFSIZ __DEFAULT_BUFSIZ__
  2009.   #endif
  2010. ***************
  2011. *** 65,71 ****
  2012.   #endif
  2013.       }
  2014.   #ifdef USE_MALLOC_BUF
  2015. !     if ((p = malloc(size)) == NULL) {
  2016.       unbuffered(1);
  2017.   //    fp->_bf._base = fp->_p = fp->_nbuf;
  2018.   //    fp->_bf._size = 1;
  2019. --- 65,71 ----
  2020.   #endif
  2021.       }
  2022.   #ifdef USE_MALLOC_BUF
  2023. !     if ((p = (char *)malloc(size)) == NULL) {
  2024.       unbuffered(1);
  2025.   //    fp->_bf._base = fp->_p = fp->_nbuf;
  2026.   //    fp->_bf._size = 1;
  2027. *** 1.10    1992/12/28 07:35:55
  2028. --- mincl    1993/02/22 17:06:36
  2029. ***************
  2030. *** 18,24 ****
  2031.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  2032.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  2033.   stdstrea.cc stream.cc streambu.cc strstrea.cc xplotfil.cc xsfile.cc \
  2034. ! igetsb.cc iodtoa.cc outfloat.cc
  2035.   
  2036.   #
  2037.   # NOTE:: dummy[12].o MUST be the last objects on this list. otherwise you'll
  2038. --- 18,24 ----
  2039.   IOSRC = editbuf.cc filebuf.cc fstream.cc igetline.cc indstrea.cc iostream.cc \
  2040.   makebuf.cc parsestr.cc sbufvfor.cc sbufvsca.cc sgetline.cc stdstrbu.cc \
  2041.   stdstrea.cc stream.cc streambu.cc strstrea.cc xplotfil.cc xsfile.cc \
  2042. ! igetsb.cc iodtoa.cc outfloat.cc iomanip.cc stdiostr.cc
  2043.   
  2044.   #
  2045.   # NOTE:: dummy[12].o MUST be the last objects on this list. otherwise you'll
  2046. ***************
  2047. *** 64,70 ****
  2048.   _bin_del.o: gnuaux.c
  2049.       $(CC) -c $(CFLAGS) -DL_builtin_del $^ -o $@
  2050.   
  2051. ! # dont ask me why, but with gcc 2.3.1 and 2.3.2 -fomit-frame-pointer
  2052.   # breaks xbitset
  2053.   xbitset.o: xbitset.cc
  2054.       $(GXX) $(GXXFFLAGS) -c xbitset.cc
  2055. --- 64,70 ----
  2056.   _bin_del.o: gnuaux.c
  2057.       $(CC) -c $(CFLAGS) -DL_builtin_del $^ -o $@
  2058.   
  2059. ! # dont ask me why, but with gcc 2.3.1 and 2.3.2/3 -fomit-frame-pointer
  2060.   # breaks xbitset
  2061.   xbitset.o: xbitset.cc
  2062.       $(GXX) $(GXXFFLAGS) -c xbitset.cc
  2063. *** 1.2    1992/07/20 22:21:08
  2064. --- outfloat.cc    1993/02/22 17:06:36
  2065. ***************
  2066. *** 17,22 ****
  2067. --- 17,25 ----
  2068.   
  2069.   #include <ioprivat.h>
  2070.   
  2071. + // Format floating-point number and print them.
  2072. + // Return number of chars printed, or EOF on error.
  2073. + 
  2074.   // sign_mode == '+' : print "-" or "+"
  2075.   // sign_mode == ' ' : print "-" or " "
  2076.   // sign_mode == '\0' : print "-' or ""
  2077. ***************
  2078. *** 25,37 ****
  2079.              int width, int precision, ios::fmtflags flags,
  2080.              char sign_mode, char fill)
  2081.   {
  2082. ! #define PUT(x) do {if (sb->sputc(x) < 0) goto error;} while (0)
  2083.   #define PUTN(p, n) \
  2084. !    do {int __n=n;if (sb->sputn(p, __n) != __n) goto error;} while (0)
  2085. ! #define PADN(fill, n) do {if (sb->padn(fill, n) < 0) goto error;} while (0)
  2086.       ios::fmtflags pad_kind = flags & (ios::left|ios::right|ios::internal);
  2087.       int skip_zeroes = 0;
  2088. !     int show_dot = flags & ios::showpoint;
  2089.       int decpt;
  2090.       int sign;
  2091.       int mode;
  2092. --- 28,42 ----
  2093.              int width, int precision, ios::fmtflags flags,
  2094.              char sign_mode, char fill)
  2095.   {
  2096. !     int count = 0;
  2097. ! #define PUT(x) do {if (sb->sputc(x) < 0) goto error; count++;} while (0)
  2098.   #define PUTN(p, n) \
  2099. !   do {_G_size_t _n=n; count+=_n; if (sb->sputn(p,_n) != _n) goto error;} while(0)
  2100. ! #define PADN(fill, n) \
  2101. !   do {_G_size_t _n = n; count+=_n; if (sb->padn(fill, _n) < 0) goto error;} while (0)
  2102.       ios::fmtflags pad_kind = flags & (ios::left|ios::right|ios::internal);
  2103.       int skip_zeroes = 0;
  2104. !     int show_dot = (flags & ios::showpoint) != 0;
  2105.       int decpt;
  2106.       int sign;
  2107.       int mode;
  2108. ***************
  2109. *** 47,61 ****
  2110. --- 52,69 ----
  2111.         case 'F':
  2112.       exp = 'e';
  2113.       mode = 0;
  2114. +     skip_zeroes = 1;
  2115.       type = 'g';
  2116.       break;
  2117.         case 'e':
  2118.       exp = 'e';
  2119.       mode = 2;
  2120. +     precision++;  // Add one to include digit before decimal point.
  2121.       break;
  2122.         case 'E':
  2123.       exp = 'E';
  2124.       mode = 2;
  2125. +     precision++;  // Add one to include digit before decimal point.
  2126.       break;
  2127.         case 'g':
  2128.         case 'G':
  2129. ***************
  2130. *** 75,81 ****
  2131.       // Check if we need to emit an exponent.
  2132.       if (mode != 3 && decpt != 9999) {
  2133.       i = decpt - 1;
  2134. !     if ((type != 'g' && type != 'F') || i <= -4 || i >= precision) {
  2135.           // Print the exponent into ebuf.
  2136.           // We write ebuf in reverse order (right-to-left).
  2137.           char sign;
  2138. --- 83,89 ----
  2139.       // Check if we need to emit an exponent.
  2140.       if (mode != 3 && decpt != 9999) {
  2141.       i = decpt - 1;
  2142. !     if ((type != 'g' && type != 'F') || i < -4 || i >= precision) {
  2143.           // Print the exponent into ebuf.
  2144.           // We write ebuf in reverse order (right-to-left).
  2145.           char sign;
  2146. ***************
  2147. *** 104,114 ****
  2148.       precision = 0;
  2149.       show_dot = 0;
  2150.       }
  2151. !     int trailing_zeroes = skip_zeroes ? 0 : precision-(useful_digits-decpt);
  2152.       if (trailing_zeroes < 0) trailing_zeroes = 0;
  2153.       if (trailing_zeroes != 0 || useful_digits > decpt)
  2154.       show_dot = 1;
  2155. -     int print_dot = 1;
  2156.       int print_sign;
  2157.       if (sign_mode == 0)
  2158.       print_sign = sign ? '-' : 0;
  2159. --- 112,135 ----
  2160.       precision = 0;
  2161.       show_dot = 0;
  2162.       }
  2163. ! 
  2164. !    // dtoa truncates trailing zeroes.  Set the variable trailing_zeroes to
  2165. !    // the number of 0's we have to add (after the decimal point).
  2166. !    int trailing_zeroes = 0;
  2167. !    if (skip_zeroes)
  2168. !        trailing_zeroes = 0;
  2169. !    else if (type == 'f')
  2170. !        trailing_zeroes = useful_digits <= decpt ? precision
  2171. !        : precision-(useful_digits-decpt);
  2172. !    else if (exponent_size) // 'e' 'E' or 'g' format using exponential notation.
  2173. !        trailing_zeroes = precision - useful_digits;
  2174. !    else // 'g' format not using exponential notation.
  2175. !        trailing_zeroes = useful_digits <= decpt ? precision - decpt
  2176. !        : precision-useful_digits;
  2177.       if (trailing_zeroes < 0) trailing_zeroes = 0;
  2178. + 
  2179.       if (trailing_zeroes != 0 || useful_digits > decpt)
  2180.       show_dot = 1;
  2181.       int print_sign;
  2182.       if (sign_mode == 0)
  2183.       print_sign = sign ? '-' : 0;
  2184. ***************
  2185. *** 147,156 ****
  2186.       }
  2187.       else {
  2188.       PUT('0');
  2189. !     PUT('.');
  2190. !     PADN('0', -decpt);
  2191. !     // Print digits after the decimal point.
  2192. !     PUTN(p, useful_digits);
  2193.       }
  2194.       PADN('0', trailing_zeroes);
  2195.       if (exponent_size)
  2196. --- 168,179 ----
  2197.       }
  2198.       else {
  2199.       PUT('0');
  2200. !     if (show_dot) {
  2201. !         PUT('.');
  2202. !         PADN('0', -decpt);
  2203. !         // Print digits after the decimal point.
  2204. !         PUTN(p, useful_digits);
  2205. !     }
  2206.       }
  2207.       PADN('0', trailing_zeroes);
  2208.       if (exponent_size)
  2209. ***************
  2210. *** 157,163 ****
  2211.       PUTN(exponent_start, exponent_size);
  2212.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  2213.       PADN(fill, padding);
  2214. !     return 0;
  2215.     error:
  2216.       return EOF;
  2217.   }
  2218. --- 180,186 ----
  2219.       PUTN(exponent_start, exponent_size);
  2220.       if (pad_kind == (ios::fmtflags)ios::left && padding > 0) // Left adjustment
  2221.       PADN(fill, padding);
  2222. !     return count;
  2223.     error:
  2224.       return EOF;
  2225.   }
  2226. *** 1.3    1992/07/20 22:21:08
  2227. --- parsestr.cc    1993/02/22 17:06:36
  2228. ***************
  2229. *** 21,32 ****
  2230.   #include <ioprivat.h>
  2231.   #include <parsestr.h>
  2232.   
  2233. ! streambuf* parsebuf::setbuf(char*, size_t)
  2234.   {
  2235.       return NULL;
  2236.   }
  2237.   
  2238. ! int parsebuf::tell_in_line()
  2239.   {
  2240.       return 0;
  2241.   }
  2242. --- 21,32 ----
  2243.   #include <ioprivat.h>
  2244.   #include <parsestr.h>
  2245.   
  2246. ! streambuf* parsebuf::setbuf(char*, _G_size_t)
  2247.   {
  2248.       return NULL;
  2249.   }
  2250.   
  2251. ! long parsebuf::tell_in_line()
  2252.   {
  2253.       return 0;
  2254.   }
  2255. ***************
  2256. *** 67,74 ****
  2257.   // The get area (eback() .. egptr()) is the extended current line
  2258.   // (i.e. with the '\n' at either end, if these exist).
  2259.   
  2260. ! string_parsebuf::string_parsebuf(char *buf, size_t len,
  2261. !                  int delete_at_close=0)
  2262.   : parsebuf()
  2263.   {
  2264.       setb(buf, buf+len, delete_at_close);
  2265. --- 67,74 ----
  2266.   // The get area (eback() .. egptr()) is the extended current line
  2267.   // (i.e. with the '\n' at either end, if these exist).
  2268.   
  2269. ! string_parsebuf::string_parsebuf(char *buf, _G_size_t len,
  2270. !                  int delete_at_close /* = 0*/)
  2271.   : parsebuf()
  2272.   {
  2273.       setb(buf, buf+len, delete_at_close);
  2274. ***************
  2275. *** 82,88 ****
  2276.   {
  2277.       register char* ptr = egptr(); // Point to end of current_line
  2278.       do {
  2279. !     long int i = right() - ptr;
  2280.       if (i <= 0)
  2281.           return EOF;
  2282.       ptr++; i--; // Skip '\n'.
  2283. --- 82,88 ----
  2284.   {
  2285.       register char* ptr = egptr(); // Point to end of current_line
  2286.       do {
  2287. !     long i = right() - ptr;
  2288.       if (i <= 0)
  2289.           return EOF;
  2290.       ptr++; i--; // Skip '\n'.
  2291. ***************
  2292. *** 104,120 ****
  2293.       return ptr;
  2294.   }
  2295.   
  2296. ! int string_parsebuf::tell_in_line()
  2297.   {
  2298. !     int offset = gptr() - eback();
  2299.       if (__line_number > 0)
  2300.       offset--;
  2301.       return offset;
  2302.   }
  2303.   
  2304. ! int string_parsebuf::seek_in_line(int i)
  2305.   {
  2306. !     int delta = i - tell_in_line();
  2307.       gbump(delta); // FIXME: Needs error (bounds) checking!
  2308.       return i;
  2309.   }
  2310. --- 104,120 ----
  2311.       return ptr;
  2312.   }
  2313.   
  2314. ! long string_parsebuf::tell_in_line()
  2315.   {
  2316. !     long offset = gptr() - eback();
  2317.       if (__line_number > 0)
  2318.       offset--;
  2319.       return offset;
  2320.   }
  2321.   
  2322. ! long string_parsebuf::seek_in_line(long i)
  2323.   {
  2324. !     long delta = i - tell_in_line();
  2325.       gbump(delta); // FIXME: Needs error (bounds) checking!
  2326.       return i;
  2327.   }
  2328. ***************
  2329. *** 126,132 ****
  2330.   {
  2331.       delete_buf = delete_arg_buf;
  2332.       sbuf = buf;
  2333. !     size_t buf_size = 128;
  2334.       char* buffer = ALLOC_BUF(buf_size);
  2335.       setb(buffer, buffer+buf_size, 1);
  2336.   //    setg(buffer, buffer, buffer);
  2337. --- 126,132 ----
  2338.   {
  2339.       delete_buf = delete_arg_buf;
  2340.       sbuf = buf;
  2341. !     _G_size_t buf_size = 128;
  2342.       char* buffer = ALLOC_BUF(buf_size);
  2343.       setb(buffer, buffer+buf_size, 1);
  2344.   //    setg(buffer, buffer, buffer);
  2345. ***************
  2346. *** 151,157 ****
  2347.       if (ch == EOF)
  2348.           break;
  2349.       if (ptr == ebuf()) {
  2350. !         size_t old_size = ebuf() - base();
  2351.           char *new_buffer = new char[old_size * 2];
  2352.           memcpy(new_buffer, base(), old_size);
  2353.           setb(new_buffer, new_buffer + 2 * old_size, 1);
  2354. --- 151,157 ----
  2355.       if (ch == EOF)
  2356.           break;
  2357.       if (ptr == ebuf()) {
  2358. !         _G_size_t old_size = ebuf() - base();
  2359.           char *new_buffer = new char[old_size * 2];
  2360.           memcpy(new_buffer, base(), old_size);
  2361.           setb(new_buffer, new_buffer + 2 * old_size, 1);
  2362. ***************
  2363. *** 178,192 ****
  2364.       return ret;
  2365.   }
  2366.   
  2367. ! int general_parsebuf::tell_in_line()
  2368.   {
  2369. !     size_t off = gptr() - base();
  2370.       if (__line_number > 1)
  2371.       off--; // Subtract 1 for '\n' from end of previous line.
  2372.       return off;
  2373.   }
  2374.   
  2375. ! int general_parsebuf::seek_in_line(int i)
  2376.   {
  2377.       if (__line_number == 0)
  2378.       (void)general_parsebuf::underflow();
  2379. --- 178,192 ----
  2380.       return ret;
  2381.   }
  2382.   
  2383. ! long general_parsebuf::tell_in_line()
  2384.   {
  2385. !     long off = gptr() - base();
  2386.       if (__line_number > 1)
  2387.       off--; // Subtract 1 for '\n' from end of previous line.
  2388.       return off;
  2389.   }
  2390.   
  2391. ! long general_parsebuf::seek_in_line(long i)
  2392.   {
  2393.       if (__line_number == 0)
  2394.       (void)general_parsebuf::underflow();
  2395. ***************
  2396. *** 193,199 ****
  2397.       if (__line_number > 1)
  2398.       i++; // Add 1 for '\n' from end of previous line.
  2399.       if (i < 0) i = 0;
  2400. !     size_t len = egptr() - eback();
  2401.       if (i > len) i = len;
  2402.       setg(base(), base() + i, egptr());
  2403.       return i;
  2404. --- 193,199 ----
  2405.       if (__line_number > 1)
  2406.       i++; // Add 1 for '\n' from end of previous line.
  2407.       if (i < 0) i = 0;
  2408. !     long len = egptr() - eback();
  2409.       if (i > len) i = len;
  2410.       setg(base(), base() + i, egptr());
  2411.       return i;
  2412. ***************
  2413. *** 210,216 ****
  2414.       backed_up_to_newline = 0;
  2415.   }
  2416.   
  2417. ! int func_parsebuf::tell_in_line()
  2418.   {
  2419.       if (buf_start == NULL)
  2420.       return 0;
  2421. --- 210,216 ----
  2422.       backed_up_to_newline = 0;
  2423.   }
  2424.   
  2425. ! long func_parsebuf::tell_in_line()
  2426.   {
  2427.       if (buf_start == NULL)
  2428.       return 0;
  2429. ***************
  2430. *** 228,234 ****
  2431.       return buf_start;
  2432.   }
  2433.   
  2434. ! int func_parsebuf::seek_in_line(int i)
  2435.   {
  2436.       if (i < 0) {
  2437.       // Back up to preceding '\n'.
  2438. --- 228,234 ----
  2439.       return buf_start;
  2440.   }
  2441.   
  2442. ! long func_parsebuf::seek_in_line(long i)
  2443.   {
  2444.       if (i < 0) {
  2445.       // Back up to preceding '\n'.
  2446. ***************
  2447. *** 238,244 ****
  2448.       return i;
  2449.       }
  2450.       backed_up_to_newline = 0;
  2451. !     int line_length = buf_end-buf_start;
  2452.       if (i <= line_length) {
  2453.       setg(buf_start, buf_start+i, buf_end);
  2454.       return i;
  2455. --- 238,244 ----
  2456.       return i;
  2457.       }
  2458.       backed_up_to_newline = 0;
  2459. !     long line_length = buf_end-buf_start;
  2460.       if (i <= line_length) {
  2461.       setg(buf_start, buf_start+i, buf_end);
  2462.       return i;
  2463. ***************
  2464. *** 288,294 ****
  2465.   }
  2466.   #endif
  2467.   
  2468. ! int parsebuf::seek_in_line(int i)
  2469.   {
  2470.   #if 1
  2471.       abort();
  2472. --- 288,294 ----
  2473.   }
  2474.   #endif
  2475.   
  2476. ! long parsebuf::seek_in_line(long i)
  2477.   {
  2478.   #if 1
  2479.       abort();
  2480. ***************
  2481. *** 296,302 ****
  2482.   #else
  2483.       if (i > 0) {
  2484.       size_t len = line_length();
  2485. !     if ((unsigned)i > len) i = len;
  2486.       }
  2487.       else if (i < -1) i = -1;
  2488.       int new_pos = seekoff(pos_at_line_start + i, ios::beg);
  2489. --- 296,302 ----
  2490.   #else
  2491.       if (i > 0) {
  2492.       size_t len = line_length();
  2493. !     if ((unsigned long)i > len) i = len;
  2494.       }
  2495.       else if (i < -1) i = -1;
  2496.       int new_pos = seekoff(pos_at_line_start + i, ios::beg);
  2497. *** 1.6    1992/07/20 22:21:08
  2498. --- sbufvfor.cc    1993/02/22 17:06:37
  2499. ***************
  2500. *** 50,58 ****
  2501.   class help_streambuf : public backupbuf {
  2502.     public:
  2503.       char *buffer;
  2504. !     size_t buf_size;
  2505.       streambuf *sb;
  2506. !     help_streambuf(streambuf *sbuf, char *buf, size_t n) {
  2507.       sb = sbuf; buffer = buf; buf_size = n;
  2508.       setp(buffer, buffer+buf_size); }
  2509.       ~help_streambuf();
  2510. --- 50,58 ----
  2511.   class help_streambuf : public backupbuf {
  2512.     public:
  2513.       char *buffer;
  2514. !     _G_size_t buf_size;
  2515.       streambuf *sb;
  2516. !     help_streambuf(streambuf *sbuf, char *buf, _G_size_t n) {
  2517.       sb = sbuf; buffer = buf; buf_size = n;
  2518.       setp(buffer, buffer+buf_size); }
  2519.       ~help_streambuf();
  2520. ***************
  2521. *** 136,148 ****
  2522.   #ifdef FLOATING_POINT
  2523.       int softsign;        /* temporary negative sign for floats */
  2524.       double _double;        /* double precision arguments %[eEfgG] */
  2525.       int fpprec;        /* `extra' floating precision in [eEfgG] */
  2526.   #endif
  2527.       unsigned long _ulong;    /* integer arguments %[diouxX] */
  2528.       enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
  2529.       int dprec;        /* a copy of prec if [diouxX], 0 otherwise */
  2530. !     int fieldsz;        /* field size expanded by sign, etc */
  2531. !     int realsz;        /* field size expanded by dprec */
  2532.       // The initialization of 'size' is to suppress a warning that
  2533.       // 'size' might be used unitialized.  It seems gcc can't
  2534.       // quite grok this spaghetti code ...
  2535. --- 136,150 ----
  2536.   #ifdef FLOATING_POINT
  2537.       int softsign;        /* temporary negative sign for floats */
  2538.       double _double;        /* double precision arguments %[eEfgG] */
  2539. + #ifndef USE_DTOA
  2540.       int fpprec;        /* `extra' floating precision in [eEfgG] */
  2541.   #endif
  2542. + #endif
  2543.       unsigned long _ulong;    /* integer arguments %[diouxX] */
  2544.       enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
  2545.       int dprec;        /* a copy of prec if [diouxX], 0 otherwise */
  2546. !     int dpad;        /* extra 0 padding needed for integers */
  2547. !     int fieldsz;        /* field size expanded by sign, dpad etc */
  2548.       // The initialization of 'size' is to suppress a warning that
  2549.       // 'size' might be used unitialized.  It seems gcc can't
  2550.       // quite grok this spaghetti code ...
  2551. ***************
  2552. *** 166,172 ****
  2553.        */
  2554.   #define    PRINT(ptr, len) \
  2555.     do { if (sputn(ptr, len) != len) goto error; } while (0)
  2556. - #define    FLUSH() { }
  2557.   #if 1
  2558.   #define PAD_SP(howmany) if (padn(' ', howmany) < 0) goto error;
  2559.   #define PAD_0(howmany) if (padn('0', howmany) < 0) goto error;
  2560. --- 168,173 ----
  2561. ***************
  2562. *** 220,226 ****
  2563.   
  2564.           flags = 0;
  2565.           dprec = 0;
  2566. ! #ifdef FLOATING_POINT
  2567.           fpprec = 0;
  2568.   #endif
  2569.           width = 0;
  2570. --- 221,227 ----
  2571.   
  2572.           flags = 0;
  2573.           dprec = 0;
  2574. ! #if defined(FLOATING_POINT) && !defined (USE_DTOA)
  2575.           fpprec = 0;
  2576.   #endif
  2577.           width = 0;
  2578. ***************
  2579. *** 254,259 ****
  2580. --- 255,261 ----
  2581.               /* FALLTHROUGH */
  2582.           case '-':
  2583.               flags |= LADJUST;
  2584. +             flags &= ~ZEROPAD; /* '-' disables '0' */
  2585.               goto rflag;
  2586.           case '+':
  2587.               sign = '+';
  2588. ***************
  2589. *** 277,283 ****
  2590.                * beginning of a field width.''
  2591.                *    -- ANSI X3J11
  2592.                */
  2593. !             flags |= ZEROPAD;
  2594.               goto rflag;
  2595.           case '1': case '2': case '3': case '4':
  2596.           case '5': case '6': case '7': case '8': case '9':
  2597. --- 279,286 ----
  2598.                * beginning of a field width.''
  2599.                *    -- ANSI X3J11
  2600.                */
  2601. !             if (!(flags & LADJUST))
  2602. !                 flags |= ZEROPAD; /* '-' disables '0' */
  2603.               goto rflag;
  2604.           case '1': case '2': case '3': case '4':
  2605.           case '5': case '6': case '7': case '8': case '9':
  2606. ***************
  2607. *** 327,342 ****
  2608.   #ifdef USE_DTOA
  2609.               {
  2610.                   ios::fmtflags fmt_flags = 0;
  2611.                   if (flags & ALT)
  2612.                   fmt_flags |= ios::showpoint;
  2613.                   if (flags & LADJUST)
  2614. !                 fmt_flags |= ios::right;
  2615. !                 if (__outfloat(_double, this, ch, width,
  2616.                          prec < 0 ? DEFPREC : prec,
  2617. !                        fmt_flags,
  2618. !                        sign,
  2619. !                        flags & ZEROPAD ? '0' : ' ') < 0)
  2620.                   goto error;
  2621.               }
  2622.               // CHECK ERROR!
  2623.               continue;
  2624. --- 330,348 ----
  2625.   #ifdef USE_DTOA
  2626.               {
  2627.                   ios::fmtflags fmt_flags = 0;
  2628. +                 int fill = ' ';
  2629.                   if (flags & ALT)
  2630.                   fmt_flags |= ios::showpoint;
  2631.                   if (flags & LADJUST)
  2632. !                 fmt_flags |= ios::left;
  2633. !                 else if (flags & ZEROPAD)
  2634. !                 fmt_flags |= ios::internal, fill = '0';
  2635. !                 n = __outfloat(_double, this, ch, width,
  2636.                          prec < 0 ? DEFPREC : prec,
  2637. !                        fmt_flags, sign, fill);
  2638. !                 if (n < 0)
  2639.                   goto error;
  2640. +                 ret += n;
  2641.               }
  2642.               // CHECK ERROR!
  2643.               continue;
  2644. ***************
  2645. *** 522,543 ****
  2646.   
  2647.           /*
  2648.            * compute actual size, so we know how much to pad.
  2649. -          * fieldsz excludes decimal prec; realsz includes it
  2650.            */
  2651. ! #ifdef FLOATING_POINT
  2652.           fieldsz = size + fpprec;
  2653.   #else
  2654.           fieldsz = size;
  2655.   #endif
  2656.           if (sign)
  2657.               fieldsz++;
  2658.           else if (flags & HEXPREFIX)
  2659.               fieldsz += 2;
  2660. !         realsz = dprec > fieldsz ? dprec : fieldsz;
  2661.   
  2662.           /* right-adjusting blank padding */
  2663.           if ((flags & (LADJUST|ZEROPAD)) == 0)
  2664. !             PAD_SP(width - realsz);
  2665.   
  2666.           /* prefix */
  2667.           if (sign) {
  2668. --- 528,552 ----
  2669.   
  2670.           /*
  2671.            * compute actual size, so we know how much to pad.
  2672.            */
  2673. ! #if defined(FLOATING_POINT) && !defined (USE_DTOA)
  2674.           fieldsz = size + fpprec;
  2675.   #else
  2676.           fieldsz = size;
  2677.   #endif
  2678. +         dpad = dprec - size;
  2679. +         if (dpad < 0)
  2680. +             dpad = 0;
  2681. + 
  2682.           if (sign)
  2683.               fieldsz++;
  2684.           else if (flags & HEXPREFIX)
  2685.               fieldsz += 2;
  2686. !         fieldsz += dpad;
  2687.   
  2688.           /* right-adjusting blank padding */
  2689.           if ((flags & (LADJUST|ZEROPAD)) == 0)
  2690. !             PAD_SP(width - fieldsz);
  2691.   
  2692.           /* prefix */
  2693.           if (sign) {
  2694. ***************
  2695. *** 550,564 ****
  2696.   
  2697.           /* right-adjusting zero padding */
  2698.           if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
  2699. !             PAD_0(width - realsz);
  2700.   
  2701.           /* leading zeroes from decimal precision */
  2702. !         PAD_0(dprec - fieldsz);
  2703.   
  2704.           /* the string or number proper */
  2705.           PRINT(cp, size);
  2706.   
  2707. ! #ifdef FLOATING_POINT
  2708.           /* trailing f.p. zeroes */
  2709.           PAD_0(fpprec);
  2710.   #endif
  2711. --- 559,573 ----
  2712.   
  2713.           /* right-adjusting zero padding */
  2714.           if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
  2715. !             PAD_0(width - fieldsz);
  2716.   
  2717.           /* leading zeroes from decimal precision */
  2718. !         PAD_0(dpad);
  2719.   
  2720.           /* the string or number proper */
  2721.           PRINT(cp, size);
  2722.   
  2723. ! #if defined(FLOATING_POINT) && !defined (USE_DTOA)
  2724.           /* trailing f.p. zeroes */
  2725.           PAD_0(fpprec);
  2726.   #endif
  2727. ***************
  2728. *** 565,579 ****
  2729.   
  2730.           /* left-adjusting padding (always blank) */
  2731.           if (flags & LADJUST)
  2732. !             PAD_SP(width - realsz);
  2733.   
  2734.           /* finally, adjust ret */
  2735. !         ret += width > realsz ? width : realsz;
  2736.   
  2737. -         FLUSH();    /* copy out the I/O vectors */
  2738.       }
  2739.   done:
  2740. -     FLUSH();
  2741.       return ret;
  2742.   error:
  2743.       return EOF;
  2744. --- 574,586 ----
  2745.   
  2746.           /* left-adjusting padding (always blank) */
  2747.           if (flags & LADJUST)
  2748. !             PAD_SP(width - fieldsz);
  2749.   
  2750.           /* finally, adjust ret */
  2751. !         ret += width > fieldsz ? width : fieldsz;
  2752.   
  2753.       }
  2754.   done:
  2755.       return ret;
  2756.   error:
  2757.       return EOF;
  2758. ***************
  2759. *** 841,843 ****
  2760. --- 848,859 ----
  2761.   }
  2762.   
  2763.   #endif /* defined(FLOATING_POINT) && !defined(USE_DTOA) */
  2764. + 
  2765. + int streambuf::form(char const *format ...)
  2766. + {
  2767. +     va_list ap;
  2768. +     va_start(ap, format);
  2769. +     int count = vform(format, ap);
  2770. +     va_end(ap);
  2771. +     return count;
  2772. + }
  2773. *** 1.5    1992/07/20 22:21:08
  2774. --- sbufvsca.cc    1993/02/22 17:06:37
  2775. ***************
  2776. *** 30,39 ****
  2777.   #include <varargs.h>
  2778.   #endif
  2779.   
  2780. - #ifdef sun /* SunOS incorrectly defines size_t to be int. */
  2781. - #define hardway
  2782. - #endif
  2783. - 
  2784.   #ifndef    NO_FLOATING_POINT
  2785.   #define FLOATING_POINT
  2786.   #endif
  2787. --- 30,35 ----
  2788. ***************
  2789. *** 88,94 ****
  2790.   
  2791.   int streambuf::vscan(char const *fmt0,
  2792.                _G_va_list ap,
  2793. !              ios::iostate *state /* = NULL */)
  2794.   {
  2795.       register const u_char *fmt = (const u_char *)fmt0;
  2796.       register int c;        /* character from format, or conversion */
  2797. --- 84,90 ----
  2798.   
  2799.   int streambuf::vscan(char const *fmt0,
  2800.                _G_va_list ap,
  2801. !              ios *stream /* = NULL */)
  2802.   {
  2803.       register const u_char *fmt = (const u_char *)fmt0;
  2804.       register int c;        /* character from format, or conversion */
  2805. ***************
  2806. *** 417,431 ****
  2807.   
  2808.           case CT_INT:
  2809.               /* scan an integer as if by strtol/strtoul */
  2810. - #ifdef hardway
  2811.               if (width == 0 || width > sizeof(buf) - 1)
  2812.                   width = sizeof(buf) - 1;
  2813. - #else
  2814. -             /* size_t is unsigned, hence this optimisation */
  2815. -             if (--width > sizeof(buf) - 2)
  2816. -                 width = sizeof(buf) - 2;
  2817. -             width++;
  2818. - #endif
  2819.               flags |= SIGNOK | NDIGITS | NZDIGITS;
  2820.               for (p = buf; width; width--) {
  2821.                   c = *_gptr;
  2822. --- 413,420 ----
  2823. ***************
  2824. *** 555,569 ****
  2825.   #ifdef FLOATING_POINT
  2826.           case CT_FLOAT:
  2827.               /* scan a floating point number as if by strtod */
  2828. - #ifdef hardway
  2829.               if (width == 0 || width > sizeof(buf) - 1)
  2830.                   width = sizeof(buf) - 1;
  2831. - #else
  2832. -             /* size_t is unsigned, hence this optimisation */
  2833. -             if (--width > sizeof(buf) - 2)
  2834. -                 width = sizeof(buf) - 2;
  2835. -             width++;
  2836. - #endif
  2837.               flags |= SIGNOK | NDIGITS | DPTOK | EXPOK;
  2838.               for (p = buf; width; width--) {
  2839.                   c = *_gptr;
  2840. --- 544,551 ----
  2841. ***************
  2842. *** 655,665 ****
  2843.       if (nassigned == 0)
  2844.           nassigned = -1;
  2845.   match_failure:
  2846. !     if (state)
  2847. !         *state |= ios::failbit;
  2848.   done:
  2849. !     if (state && seen_eof)
  2850. !         *state |= ios::eofbit;
  2851.       return (nassigned);
  2852.   }
  2853.   
  2854. --- 637,647 ----
  2855.       if (nassigned == 0)
  2856.           nassigned = -1;
  2857.   match_failure:
  2858. !     if (stream)
  2859. !         stream->set(ios::failbit);
  2860.   done:
  2861. !     if (stream && seen_eof)
  2862. !         stream->set(ios::eofbit);
  2863.       return (nassigned);
  2864.   }
  2865.   
  2866. ***************
  2867. *** 756,759 ****
  2868. --- 738,750 ----
  2869.           }
  2870.       }
  2871.       /* NOTREACHED */
  2872. + }
  2873. + 
  2874. + int streambuf::scan(char const *format ...)
  2875. + {
  2876. +     va_list ap;
  2877. +     va_start(ap, format);
  2878. +     int count = vscan(format, ap);
  2879. +     va_end(ap);
  2880. +     return count;
  2881.   }
  2882. *** 1.3    1992/06/08 20:42:41
  2883. --- sgetline.cc    1993/02/22 17:06:38
  2884. ***************
  2885. *** 21,27 ****
  2886.   
  2887.   // Read chars into buf (of size n), until delim is seen.
  2888.   // Return number of chars read (at most n-1).
  2889. ! // If extract_delim < 0, leave delimited unread.
  2890.   // If extract_delim > 0, insert delim in output.
  2891.   
  2892.   long streambuf::sgetline(char* buf, size_t n, char delim, int extract_delim)
  2893. --- 21,27 ----
  2894.   
  2895.   // Read chars into buf (of size n), until delim is seen.
  2896.   // Return number of chars read (at most n-1).
  2897. ! // If extract_delim < 0, leave delimiter unread.
  2898.   // If extract_delim > 0, insert delim in output.
  2899.   
  2900.   long streambuf::sgetline(char* buf, size_t n, char delim, int extract_delim)
  2901. *** 1.4    1992/06/03 02:12:17
  2902. --- stdstrbu.cc    1993/02/22 17:06:38
  2903. ***************
  2904. *** 16,28 ****
  2905.   //    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  2906.   
  2907.   #include <ioprivat.h>
  2908. ! #include <g_config.h>
  2909.   
  2910. ! #if _G_NAMES_HAVE_UNDERSCORE
  2911. ! #define UNDERSCORE "_"
  2912. ! #else
  2913. ! #define UNDERSCORE ""
  2914. ! #endif
  2915.   
  2916.   // To avoid problems depending on constructor order (and for
  2917.   // efficiency) the standard streambufs (and streams) are
  2918. --- 16,32 ----
  2919.   //    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  2920.   
  2921.   #include <ioprivat.h>
  2922. ! #include <stdio.h>
  2923.   
  2924. ! // This file defines the standard streambufs, corresponding to cin, cout, cerr.
  2925. ! // We define two sets:
  2926. ! //
  2927. ! // __std_filebuf_0, __std_filebuf_1, __std_filebuf_2 are filebufs using
  2928. ! // file descriptor 0/1/2.
  2929. ! //
  2930. ! // __stdin_stdiobuf, __stdout_stdiobuf, __stderr_stdiobuf are stdiostreams
  2931. ! // pointing to stdin, stdout, stderr.
  2932. ! 
  2933.   
  2934.   // To avoid problems depending on constructor order (and for
  2935.   // efficiency) the standard streambufs (and streams) are
  2936. ***************
  2937. *** 35,40 ****
  2938. --- 39,52 ----
  2939.   // (the address of) the virtual function table for the
  2940.   // filebuf class.
  2941.   
  2942. + #if _G_NAMES_HAVE_UNDERSCORE
  2943. + #define UNDERSCORE "_"
  2944. + #else
  2945. + #define UNDERSCORE ""
  2946. + #endif
  2947. + 
  2948. + // First define the filebuf-based objects.
  2949. + 
  2950.   #if !defined(vt_filebuf)
  2951.   #ifndef __GNUG__
  2952.   // This works for cfront.
  2953. ***************
  2954. *** 53,68 ****
  2955.       struct __file_fields f;
  2956.   };
  2957.   
  2958. ! #define DEF_STD(NAME, FD, CHAIN, FLAGS) \
  2959. !     _fake_filebuf NAME[1] = {{\
  2960.          { _IO_MAGIC+_S_LINKED+_S_IS_FILEBUF+_S_IS_BACKUPBUF+FLAGS, \
  2961. !      0, 0, 0, 0, 0, 0, 0, 0, CHAIN, 0, 0, 0, 0, 0},\
  2962. !        vt_filebuf, {FD}}};
  2963.   
  2964. ! DEF_STD(_cin_sbuf, 0, 0, _S_NO_WRITES);
  2965. ! DEF_STD(_cout_sbuf, 1, (streambuf*)_cin_sbuf, _S_NO_READS);
  2966. ! DEF_STD(_cerr_sbuf, 2, (streambuf*)_cout_sbuf, _S_NO_READS);
  2967.   
  2968. ! DEF_STD(not_open_filebuf, -1, (streambuf*)0, _S_NO_READS+_S_NO_WRITES);
  2969.   
  2970. ! streambuf* streambuf::_list_all = (streambuf*)_cerr_sbuf;
  2971. --- 65,112 ----
  2972.       struct __file_fields f;
  2973.   };
  2974.   
  2975. ! #define FILEBUF_LITERAL(CHAIN, FLAGS) \
  2976.          { _IO_MAGIC+_S_LINKED+_S_IS_FILEBUF+_S_IS_BACKUPBUF+FLAGS, \
  2977. !      0, 0, 0, 0, 0, 0, 0, 0, CHAIN, 0, 0, 0, 0, 0}
  2978.   
  2979. ! #define DEF_FILEBUF(NAME, FD, CHAIN, FLAGS) \
  2980. !   _fake_filebuf NAME[1] = {{FILEBUF_LITERAL(CHAIN, FLAGS), vt_filebuf, {FD}}};
  2981.   
  2982. ! DEF_FILEBUF(__std_filebuf_0, 0, 0, _S_NO_WRITES);
  2983. ! DEF_FILEBUF(__std_filebuf_1, 1, (streambuf*)__std_filebuf_0, _S_NO_READS);
  2984. ! DEF_FILEBUF(__std_filebuf_2, 2, (streambuf*)__std_filebuf_1,
  2985. !         _S_NO_READS+_S_UNBUFFERED);
  2986. ! 
  2987. ! // Nest define the stdiobuf-bases objects.
  2988. ! 
  2989. ! #if !defined(vt_stdiobuf)
  2990. ! #ifndef __GNUG__
  2991. ! // This works for cfront.
  2992. ! #define vt_stdiobuf __vtbl__7stdiobuf
  2993. ! extern char vt_stdiobuf[1];
  2994. ! #elif _G_DOLLAR_IN_LABEL
  2995. ! extern char vt_stdiobuf[1] asm(UNDERSCORE "_vt$stdiobuf");
  2996. ! #else
  2997. ! extern char vt_stdiobuf[1] asm(UNDERSCORE "_vt.stdiobuf");
  2998. ! #endif
  2999. ! #endif /* !defined(vt_stdiobuf) */
  3000. ! 
  3001. ! struct _fake_stdiobuf {
  3002. !     struct __streambuf s;
  3003. !     char* vtable;
  3004. !     struct __file_fields f;
  3005. !     FILE *_f;
  3006. ! };
  3007.   
  3008. ! #define DEF_STDIOBUF(NAME, FILE, FD, CHAIN, FLAGS) \
  3009. !     _fake_stdiobuf NAME[1] = {{ \
  3010. !      FILEBUF_LITERAL(CHAIN, (FLAGS)|_S_UNBUFFERED),\
  3011. !      vt_stdiobuf, {FD}, FILE}};
  3012. ! 
  3013. ! DEF_STDIOBUF(__stdin_stdiobuf, stdin, 0, (streambuf*)__std_filebuf_2,
  3014. !          _S_NO_WRITES);
  3015. ! DEF_STDIOBUF(__stdout_stdiobuf, stdout, 1, (streambuf*)__stdin_stdiobuf,
  3016. !          _S_NO_READS);
  3017. ! DEF_STDIOBUF(__stderr_stdiobuf, stderr, 2, (streambuf*)__stdout_stdiobuf,
  3018. !          _S_NO_READS);
  3019. ! streambuf* streambuf::_list_all = (streambuf*)__stderr_stdiobuf;
  3020. *** 1.4    1992/06/03 02:12:17
  3021. --- stdstrea.cc    1993/02/22 17:06:38
  3022. ***************
  3023. *** 18,40 ****
  3024.   #include <ioprivat.h>
  3025.   #include <g_config.h>
  3026.   
  3027. ! #if _G_NAMES_HAVE_UNDERSCORE
  3028.   #define UNDERSCORE "_"
  3029.   #else
  3030.   #define UNDERSCORE ""
  3031.   #endif
  3032.   
  3033. ! struct _fake_filebuf;
  3034. ! 
  3035. ! extern _fake_filebuf _cin_sbuf, _cout_sbuf, _cerr_sbuf;
  3036. ! 
  3037. ! #if 0 /* defined(__GNUC__) */
  3038. ! // This hack was intended to trick gdb into thinking cin is really a
  3039. ! // istream (and not a _fake_istream), but doesn't seem to work.
  3040. ! #define STR_NAME(TYPE, NAME) TYPE __##NAME asm(UNDERSCORE #NAME)
  3041.   #else
  3042. ! #define STR_NAME(TYPE, NAME) TYPE NAME
  3043.   #endif
  3044.   #define cin CIN
  3045.   #define cout COUT
  3046.   #define cerr CERR
  3047. --- 18,58 ----
  3048.   #include <ioprivat.h>
  3049.   #include <g_config.h>
  3050.   
  3051. ! // The ANSI draft requires that operations on cin/cout/cerr can be
  3052. ! // mixed with operations on stdin/stdout/stderr on a character by
  3053. ! // character basis.  This normally requires that the streambuf's
  3054. ! // used by cin/cout/cerr be stdiostreams.  However, if the stdio
  3055. ! // implementation is the one that is built using this library,
  3056. ! // then we don't need to, since in that case stdin/stdout/stderr
  3057. ! // are identical to &__std_filebuf_0/&__std_filebuf_1/&__std_filebuf_2.
  3058. ! 
  3059. ! #ifdef _STDIO_USES_IOSTREAM
  3060. ! #define USE_FILEBUF
  3061. ! #endif
  3062. ! 
  3063. ! #if defined(NAMES_HAVE_UNDERSCORE) || defined(_G_NAMES_HAVE_UNDERSCORE)
  3064.   #define UNDERSCORE "_"
  3065.   #else
  3066.   #define UNDERSCORE ""
  3067.   #endif
  3068.   
  3069. ! #ifdef USE_FILEBUF
  3070. ! #define CIN_SBUF __std_filebuf_0
  3071. ! #define COUT_SBUF __std_filebuf_1
  3072. ! #define CERR_SBUF __std_filebuf_2
  3073. ! static int use_stdiobuf = 0;
  3074.   #else
  3075. ! #define CIN_SBUF __stdin_stdiobuf
  3076. ! #define COUT_SBUF __stdout_stdiobuf
  3077. ! #define CERR_SBUF __stderr_stdiobuf
  3078. ! static int use_stdiobuf = 1;
  3079.   #endif
  3080. + 
  3081. + struct _fake_filebuf;
  3082. + extern _fake_filebuf __std_filebuf_0, __std_filebuf_1, __std_filebuf_2;
  3083. + struct _fake_stdiobuf;
  3084. + extern _fake_stdiobuf __stdin_stdiobuf, __stdout_stdiobuf, __stderr_stdiobuf;
  3085. + 
  3086.   #define cin CIN
  3087.   #define cout COUT
  3088.   #define cerr CERR
  3089. ***************
  3090. *** 50,71 ****
  3091.   #else
  3092.   #define PAD 1
  3093.   #endif
  3094. ! class _fake_istream {
  3095.       _ios_fields base;
  3096.       char filler[sizeof(struct istream)-sizeof(struct _ios_fields)+PAD];
  3097.   };
  3098. ! class _fake_ostream {
  3099.       _ios_fields base;
  3100.       char filler[sizeof(struct ostream)-sizeof(struct _ios_fields)+PAD];
  3101.   };
  3102.   
  3103.   #define STD_STR(SBUF, TIE, EXTRA_FLAGS) \
  3104. !  (streambuf*)&SBUF, TIE, 0, ios::dont_close|ios::skipws|EXTRA_FLAGS, ' ', 0, 6
  3105.   
  3106. ! STR_NAME(_fake_ostream, cout)  = { STD_STR(_cout_sbuf, NULL, 0) };
  3107. ! STR_NAME(_fake_ostream, cerr) =
  3108. !   { STD_STR(_cerr_sbuf, (ostream*)&cout, ios::unitbuf) };
  3109. ! STR_NAME(_fake_istream, cin)  = { STD_STR(_cin_sbuf,  (ostream*)&cout, 0) };
  3110.   
  3111.   /* Only for (partial) compatibility with AT&T's library. */
  3112. ! STR_NAME(_fake_ostream, clog) = { STD_STR(_cerr_sbuf, (ostream*)&cout, 0) };
  3113. --- 68,127 ----
  3114.   #else
  3115.   #define PAD 1
  3116.   #endif
  3117. ! struct _fake_istream {
  3118. !     struct myfields {
  3119. !     _ios_fields *vb; /* pointer to virtual base class ios */
  3120. !     _G_ssize_t _gcount;
  3121. !     } mine;
  3122.       _ios_fields base;
  3123.       char filler[sizeof(struct istream)-sizeof(struct _ios_fields)+PAD];
  3124.   };
  3125. ! struct _fake_ostream {
  3126. !     struct myfields {
  3127. !     _ios_fields *vb; /* pointer to virtual base class ios */
  3128. !     } mine;
  3129.       _ios_fields base;
  3130.       char filler[sizeof(struct ostream)-sizeof(struct _ios_fields)+PAD];
  3131.   };
  3132.   
  3133.   #define STD_STR(SBUF, TIE, EXTRA_FLAGS) \
  3134. !  (streambuf*)&SBUF, TIE, 0, ios::dont_close|ios::skipws|EXTRA_FLAGS, ' ',0,0,6
  3135. ! 
  3136. ! #define STREAM_DEF(TYPE, NAME, SBUF, TIE, EXTRA_FLAGS) \
  3137. !   TYPE NAME = { {&NAME.base}, {STD_STR(SBUF, TIE, EXTRA_FLAGS) }};
  3138.   
  3139. ! STREAM_DEF(_fake_ostream, cout, COUT_SBUF, NULL, 0)
  3140. ! STREAM_DEF(_fake_ostream, cerr, CERR_SBUF, (ostream*)&cout, ios::unitbuf)
  3141. ! STREAM_DEF(_fake_istream, cin, CIN_SBUF,  (ostream*)&cout, 0)
  3142.   
  3143.   /* Only for (partial) compatibility with AT&T's library. */
  3144. ! STREAM_DEF(_fake_ostream, clog, CERR_SBUF, (ostream*)&cout, 0)
  3145. ! 
  3146. ! // Switches between using __std_filebuf_{0,1,2} and
  3147. ! // __std{in,out,err}_stdiobuf for standard streams.  This is
  3148. ! // normally not needed, but is provided for AT&T compatibility.
  3149. ! 
  3150. ! int ios::sync_with_stdio(int new_state)
  3151. ! {
  3152. ! #ifdef _STDIO_USES_IOSTREAM
  3153. !     // It is always synced.
  3154. !     return 0;
  3155. ! #else
  3156. !     if (new_state == use_stdiobuf) // The usual case now.
  3157. !     return use_stdiobuf;
  3158. !     if (new_state) {
  3159. !     cout.base._strbuf = (streambuf*)&__stdout_stdiobuf;
  3160. !     cin.base._strbuf = (streambuf*)&__stdin_stdiobuf;
  3161. !     cerr.base._strbuf = (streambuf*)&__stderr_stdiobuf;
  3162. !     clog.base._strbuf = (streambuf*)&__stderr_stdiobuf;
  3163. !     } else {
  3164. !     cout.base._strbuf = (streambuf*)&__std_filebuf_1;
  3165. !     cin.base._strbuf = (streambuf*)&__std_filebuf_0;
  3166. !     cerr.base._strbuf = (streambuf*)&__std_filebuf_2;
  3167. !     clog.base._strbuf = (streambuf*)&__std_filebuf_2;
  3168. !     }
  3169. !     int old_state = use_stdiobuf;
  3170. !     use_stdiobuf = new_state;
  3171. !     return old_state;
  3172. ! #endif
  3173. ! }
  3174. *** 1.5    1992/06/03 02:12:17
  3175. --- stream.cc    1993/02/22 17:06:39
  3176. ***************
  3177. *** 17,23 ****
  3178.   
  3179.   char* form(const char* format, ...)
  3180.   {
  3181. !     size_t space_left = EndBuffer - next_chunk;
  3182.       // If less that 25% of the space is available start over.
  3183.       if (space_left < (BUFSIZ>>2))
  3184.       next_chunk = Buffer;
  3185. --- 17,23 ----
  3186.   
  3187.   char* form(const char* format, ...)
  3188.   {
  3189. !     _G_size_t space_left = EndBuffer - next_chunk;
  3190.       // If less that 25% of the space is available start over.
  3191.       if (space_left < (BUFSIZ>>2))
  3192.       next_chunk = Buffer;
  3193. ***************
  3194. *** 41,47 ****
  3195.       // for each input byte, but normally 3 is plenty.
  3196.       int needed = size ? size
  3197.       : (base >= 8 ? 3 : 8) * sizeof(unsigned long) + 2;
  3198. !     size_t space_left = EndBuffer - next_chunk;
  3199.       if (space_left <= needed)
  3200.       next_chunk = Buffer; // start over.
  3201.   
  3202. --- 41,47 ----
  3203.       // for each input byte, but normally 3 is plenty.
  3204.       int needed = size ? size
  3205.       : (base >= 8 ? 3 : 8) * sizeof(unsigned long) + 2;
  3206. !     _G_size_t space_left = EndBuffer - next_chunk;
  3207.       if (space_left <= needed)
  3208.       next_chunk = Buffer; // start over.
  3209.   
  3210. *** 1.6    1992/07/20 22:21:08
  3211. --- streambu.cc    1993/02/22 17:06:39
  3212. ***************
  3213. *** 22,27 ****
  3214. --- 22,50 ----
  3215.   #include <ioprivat.h>
  3216.   #include <string.h>
  3217.   
  3218. + void streambuf::_un_link()
  3219. + {
  3220. +     if (_flags & _S_LINKED) {
  3221. +     streambuf **f;
  3222. +     for (f = &_list_all; *f != NULL; f = &(*f)->xchain()) {
  3223. +         if (*f == this) {
  3224. +         *f = xchain();
  3225. +         break;
  3226. +         }
  3227. +     }
  3228. +     _flags &= ~_S_LINKED;
  3229. +     }
  3230. + }
  3231. + 
  3232. + void streambuf::_link_in()
  3233. + {
  3234. +     if ((_flags & _S_LINKED) == 0) {
  3235. +     _flags |= _S_LINKED;
  3236. +     xchain() = _list_all;
  3237. +     _list_all = this;
  3238. +     }
  3239. + }
  3240. + 
  3241.   // Return minimum _pos markers
  3242.   // Assumes the current get area is the main get area.
  3243.   long streambuf::_least_marker()
  3244. ***************
  3245. *** 190,196 ****
  3246.   // for the atari we take a hit here so that bin/text modes are taken care of
  3247.   // automatically by sputc/sbumpc
  3248.   
  3249. ! size_t streambuf::sputn(const char* s, size_t n) // OPTIMIZE THIS!
  3250.   {
  3251.       size_t count = 0;
  3252.   
  3253. --- 213,219 ----
  3254.   // for the atari we take a hit here so that bin/text modes are taken care of
  3255.   // automatically by sputc/sbumpc
  3256.   
  3257. ! _G_size_t streambuf::xsputn(const char* s, _G_size_t n) // OPTIMIZE THIS!
  3258.   {
  3259.       size_t count = 0;
  3260.   
  3261. ***************
  3262. *** 203,209 ****
  3263.       return count;
  3264.   }
  3265.   
  3266. ! size_t streambuf::sgetn(char* s, size_t n) // OPTIMIZE THIS!
  3267.   {
  3268.       size_t count = 0;
  3269.       for (; count < n; count++) {
  3270. --- 226,232 ----
  3271.       return count;
  3272.   }
  3273.   
  3274. ! _G_size_t streambuf::xsgetn(char* s, _G_size_t n) // OPTIMIZE THIS!
  3275.   {
  3276.       size_t count = 0;
  3277.       for (; count < n; count++) {
  3278. ***************
  3279. *** 215,221 ****
  3280.       return count;
  3281.   }
  3282.   
  3283. ! size_t streambuf::ignore(size_t n)
  3284.   {
  3285.       size_t more = n;
  3286.       int ch;
  3287. --- 238,244 ----
  3288.       return count;
  3289.   }
  3290.   
  3291. ! _G_size_t streambuf::ignore(_G_size_t n)
  3292.   {
  3293.       size_t more = n;
  3294.       int ch;
  3295. ***************
  3296. *** 225,237 ****
  3297.   }
  3298.   
  3299.   #else
  3300. ! size_t streambuf::sputn(register const char* s, size_t n)
  3301.   {
  3302. !     if (n <= 0)
  3303.       return 0;
  3304. !     register size_t more = n;
  3305.       for (;;) {
  3306. !     size_t count = _epptr - _pptr; // Space available.
  3307.       if (count > 0) {
  3308.           if (count > more)
  3309.           count = more;
  3310. --- 248,261 ----
  3311.   }
  3312.   
  3313.   #else
  3314. ! 
  3315. ! _G_size_t streambuf::xsputn(register const char* s, _G_size_t n)
  3316.   {
  3317. !     if ((long)n <= 0)
  3318.       return 0;
  3319. !     register _G_size_t more = n;
  3320.       for (;;) {
  3321. !     long count = _epptr - _pptr; // Space available.
  3322.       if (count > 0) {
  3323.           if (count > more)
  3324.           count = more;
  3325. ***************
  3326. *** 257,267 ****
  3327.   }
  3328.   
  3329.   
  3330. ! size_t streambuf::sgetn(char* s, size_t n)
  3331.   {
  3332. !     register size_t more = n;
  3333.       for (;;) {
  3334. !     size_t count = _egptr - _gptr; // Data available.
  3335.       if (count > 0) {
  3336.           if (count > more)
  3337.           count = more;
  3338. --- 281,291 ----
  3339.   }
  3340.   
  3341.   
  3342. ! _G_size_t streambuf::xsgetn(char* s, _G_size_t n)
  3343.   {
  3344. !     register _G_size_t more = n;
  3345.       for (;;) {
  3346. !     long count = _egptr - _gptr; // Data available.
  3347.       if (count > 0) {
  3348.           if (count > more)
  3349.           count = more;
  3350. ***************
  3351. *** 285,295 ****
  3352.       return n - more;
  3353.   }
  3354.   
  3355. ! size_t streambuf::ignore(size_t n)
  3356.   {
  3357. !     register size_t more = n;
  3358.       for (;;) {
  3359. !     long count = _egptr - _gptr; // Data available.
  3360.       if (count > 0) {
  3361.           if (count > more)
  3362.           count = more;
  3363. --- 309,319 ----
  3364.       return n - more;
  3365.   }
  3366.   
  3367. ! _G_size_t streambuf::ignore(_G_size_t n)
  3368.   {
  3369. !     register _G_size_t more = n;
  3370.       for (;;) {
  3371. !     int long = _egptr - _gptr; // Data available.
  3372.       if (count > 0) {
  3373.           if (count > more)
  3374.           count = more;
  3375. ***************
  3376. *** 301,309 ****
  3377.       }
  3378.       return n - more;
  3379.   }
  3380. ! #endif /* atari */
  3381.   
  3382. ! int streambuf::padn(char pad, int count)
  3383.   {
  3384.   #define PADSIZE 16
  3385.       static char const blanks[PADSIZE] =
  3386. --- 325,333 ----
  3387.       }
  3388.       return n - more;
  3389.   }
  3390. ! #endif
  3391.   
  3392. ! int streambuf::padn(char pad, _G_size_t count)
  3393.   {
  3394.   #define PADSIZE 16
  3395.       static char const blanks[PADSIZE] =
  3396. ***************
  3397. *** 312,318 ****
  3398.        {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
  3399.       char padbuf[PADSIZE];
  3400.       const char *padptr;
  3401. !     register int i;
  3402.       
  3403.       if (pad == ' ')
  3404.       padptr = blanks;
  3405. --- 336,342 ----
  3406.        {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
  3407.       char padbuf[PADSIZE];
  3408.       const char *padptr;
  3409. !     register long i;
  3410.       
  3411.       if (pad == ' ')
  3412.       padptr = blanks;
  3413. ***************
  3414. *** 339,355 ****
  3415.   
  3416.   int streambuf::pbackfail(int c)
  3417.   {
  3418. !     return EOF;
  3419. ! }
  3420. ! 
  3421. ! int streambuf::ungetfail()
  3422. ! {
  3423. !     if (seekoff(-1, ios::cur, ios::in) == EOF)
  3424.       return EOF;
  3425. !     return sgetc();
  3426.   }
  3427.   
  3428. ! streambuf* streambuf::setbuf(char* p, size_t len)
  3429.   {
  3430.       if (sync() == EOF)
  3431.       return NULL;
  3432. --- 363,378 ----
  3433.   
  3434.   int streambuf::pbackfail(int c)
  3435.   {
  3436. !     if (_gptr > _eback)
  3437. !     _gptr--;
  3438. !     else if (seekoff(-1, ios::cur, ios::in) == EOF)
  3439.       return EOF;
  3440. !     if (c != EOF && *_gptr != c)
  3441. !     *_gptr = c;
  3442. !     return (unsigned char)c;
  3443.   }
  3444.   
  3445. ! streambuf* streambuf::setbuf(char* p, _G_size_t len)
  3446.   {
  3447.       if (sync() == EOF)
  3448.       return NULL;
  3449. ***************
  3450. *** 388,394 ****
  3451.   
  3452.   int streambuf::doallocate()
  3453.   {
  3454. !     char *buf = malloc((size_t)__DEFAULT_BUFSIZ__);
  3455.       if (buf == NULL)
  3456.       return EOF;
  3457.       setb(buf, buf+__DEFAULT_BUFSIZ__, 1);
  3458. --- 411,417 ----
  3459.   
  3460.   int streambuf::doallocate()
  3461.   {
  3462. !     char *buf = (char *)malloc((size_t)__DEFAULT_BUFSIZ__);
  3463.       if (buf == NULL)
  3464.       return EOF;
  3465.       setb(buf, buf+__DEFAULT_BUFSIZ__, 1);
  3466. ***************
  3467. *** 412,421 ****
  3468.   }
  3469.   
  3470.   #ifdef atarist
  3471. ! extern "C" extern int __default_mode__;
  3472.   #endif
  3473.   
  3474. ! streambuf::streambuf(long flags)
  3475.   {
  3476.   #ifdef atarist
  3477.     if(!(flags & _IOS_TEXT))
  3478. --- 435,444 ----
  3479.   }
  3480.   
  3481.   #ifdef atarist
  3482. ! extern "C" int __default_mode__;
  3483.   #endif
  3484.   
  3485. ! streambuf::streambuf(unsigned long flags)
  3486.   {
  3487.   #ifdef atarist
  3488.     if(!(flags & _IOS_TEXT))
  3489. ***************
  3490. *** 461,482 ****
  3491.   
  3492.   int streambuf::sputbackc(char c)
  3493.   {
  3494. !     if (gptr() <= eback()) return pbackfail(c);
  3495. !     gbump(-1);
  3496. !     // Don't write into the get buffer if we don't have to.
  3497. !     if (*gptr() != c)
  3498. !     *gptr() = c;
  3499. !     return (unsigned char)c;
  3500.   }
  3501.   
  3502.   int streambuf::sungetc()
  3503.   {
  3504. !     if (gptr() > eback()) {
  3505. !     gbump(-1);
  3506. !     return (unsigned char)*gptr();
  3507.       }
  3508.       else
  3509. !     return ungetfail();
  3510.   }
  3511.   
  3512.   #if 0 /* Work in progress */
  3513. --- 484,504 ----
  3514.   
  3515.   int streambuf::sputbackc(char c)
  3516.   {
  3517. !     if (_gptr > _eback && (unsigned char)_gptr[-1] == (unsigned char)c) {
  3518. !     _gptr--;
  3519. !     return (unsigned char)c;
  3520. !     }
  3521. !     return pbackfail(c);
  3522.   }
  3523.   
  3524.   int streambuf::sungetc()
  3525.   {
  3526. !     if (_gptr > _eback) {
  3527. !     _gptr--;
  3528. !     return (unsigned char)*_gptr;
  3529.       }
  3530.       else
  3531. !     return pbackfail(EOF);
  3532.   }
  3533.   
  3534.   #if 0 /* Work in progress */
  3535. ***************
  3536. *** 499,505 ****
  3537.   
  3538.   int streambuf::set_column(int i)
  3539.   {
  3540. -     overflow(EOF);
  3541.       _cur_column = i+1;
  3542.       return 0;
  3543.   }
  3544. --- 521,526 ----
  3545. ***************
  3546. *** 606,612 ****
  3547.       }
  3548.   }
  3549.   
  3550. ! int streambuf::seekmark(streammarker& mark, int delta = 0)
  3551.   {
  3552.       if (mark._sbuf != this)
  3553.       return EOF;
  3554. --- 627,633 ----
  3555.       }
  3556.   }
  3557.   
  3558. ! int streambuf::seekmark(streammarker& mark, long delta /* = 0 */)
  3559.   {
  3560.       if (mark._sbuf != this)
  3561.       return EOF;
  3562. ***************
  3563. *** 673,682 ****
  3564.       setg(new_buf, new_buf+(new_size-old_size), new_buf+new_size);
  3565.       _aux_limit = _gptr;
  3566.       }
  3567. !     gbump(-1);
  3568. !     if (*gptr() != c)
  3569. !     *gptr() = c;
  3570. !     return (unsigned char)c;
  3571.   }
  3572.   
  3573.   unsigned __adjust_column(unsigned start, const char *line, int count)
  3574. --- 694,703 ----
  3575.       setg(new_buf, new_buf+(new_size-old_size), new_buf+new_size);
  3576.       _aux_limit = _gptr;
  3577.       }
  3578. !     _gptr--;
  3579. !     if (c != EOF && *_gptr != c)
  3580. !     *_gptr = c;
  3581. !     return (unsigned char)*_gptr;
  3582.   }
  3583.   
  3584.   unsigned __adjust_column(unsigned start, const char *line, int count)
  3585. ***************
  3586. *** 688,693 ****
  3587. --- 709,719 ----
  3588.       return start + count;
  3589.   }
  3590.   
  3591. + int ios::readable() { return !(rdbuf()->_flags & _S_NO_READS); }
  3592. + int ios::writable() { return !(rdbuf()->_flags & _S_NO_WRITES); }
  3593. + int ios::is_open() { return rdbuf()
  3594. +              && (rdbuf()->_flags & _S_NO_READS+_S_NO_WRITES)
  3595. +                  != _S_NO_READS+_S_NO_WRITES; }
  3596.   
  3597.   #if defined(linux)
  3598.   #define IO_CLEANUP ;
  3599. *** 1.6    1992/07/17 18:24:43
  3600. --- strstrea.cc    1993/02/22 17:06:39
  3601. ***************
  3602. *** 21,58 ****
  3603.   #include <ioprivat.h>
  3604.   #include <strstrea.h>
  3605.   
  3606. ! istrstream::istrstream(char *cp) : istream(NULL)
  3607.   {
  3608. !     _strbuf = new strstreambuf(cp, 0, NULL);
  3609.   }
  3610.   
  3611. ! istrstream::istrstream(char *cp, int n) : istream(NULL)
  3612.   {
  3613. !     _strbuf = new strstreambuf(cp, n, NULL);
  3614.   }
  3615.   
  3616. ! ostrstream::ostrstream() : ostream(NULL)
  3617.   {
  3618. !     _strbuf = new strstreambuf;
  3619.   }
  3620.   
  3621. ! ostrstream::ostrstream(char *cp, int n, int mode) : ostream(NULL)
  3622.   {
  3623. !     char *pstart;
  3624. !     if (mode == ios::app || mode == ios::ate)
  3625. !     pstart = cp + strlen(cp);
  3626. !     else
  3627. !     pstart = cp;
  3628. !     _strbuf = new strstreambuf(cp, n, pstart);
  3629. ! }
  3630. ! 
  3631. ! 
  3632. ! strstream::strstream() : iostream(NULL)
  3633. ! {
  3634. !     _strbuf = new strstreambuf;
  3635.   }
  3636.   
  3637. ! strstream::strstream(char *cp, int n, int mode) : iostream(NULL)
  3638.   {
  3639.       char *pstart;
  3640.       if (mode == ios::app || mode == ios::ate)
  3641. --- 21,47 ----
  3642.   #include <ioprivat.h>
  3643.   #include <strstrea.h>
  3644.   
  3645. ! static void* default_alloc(_G_size_t size)
  3646.   {
  3647. !     return (void*)new char[size];
  3648.   }
  3649.   
  3650. ! static void default_free(void* ptr)
  3651.   {
  3652. !     delete [] (char*)ptr;
  3653.   }
  3654.   
  3655. ! istrstream::istrstream(const char *cp, _G_size_t n)
  3656.   {
  3657. !     init(new strstreambuf(cp, n));
  3658.   }
  3659.   
  3660. ! ostrstream::ostrstream()
  3661.   {
  3662. !     init(new strstreambuf());
  3663.   }
  3664.   
  3665. ! strstreambase::strstreambase(char *cp, _G_size_t n, int mode)
  3666.   {
  3667.       char *pstart;
  3668.       if (mode == ios::app || mode == ios::ate)
  3669. ***************
  3670. *** 59,72 ****
  3671.       pstart = cp + strlen(cp);
  3672.       else
  3673.       pstart = cp;
  3674. !     _strbuf = new strstreambuf(cp, n, pstart);
  3675.   }
  3676.   
  3677. - 
  3678.   char *strstreambuf::str()
  3679.   {
  3680.       freeze(1);
  3681. !     return _buffer;
  3682.   }
  3683.   
  3684.   _G_size_t strstreambuf::pcount()
  3685. --- 48,60 ----
  3686.       pstart = cp + strlen(cp);
  3687.       else
  3688.       pstart = cp;
  3689. !     init(new strstreambuf(cp, n, pstart));
  3690.   }
  3691.   
  3692.   char *strstreambuf::str()
  3693.   {
  3694.       freeze(1);
  3695. !     return base();
  3696.   }
  3697.   
  3698.   _G_size_t strstreambuf::pcount()
  3699. ***************
  3700. *** 76,112 ****
  3701.       return put_len;
  3702.   }
  3703.   
  3704. ! int strstreambuf::overflow(int c = EOF)
  3705.   {
  3706.     const int flush_only = c == EOF;
  3707.     size_t pos = pptr() - pbase();
  3708.     size_t get_pos = gptr() - pbase();
  3709.     if (pos > _len) _len = pos;
  3710. !   if (pos >= _size + flush_only) {
  3711.         char *new_buf;
  3712. !       size_t new_size = 2 * _size;
  3713. !       if (_frozen) /* not allowed to enlarge */
  3714.         return EOF;
  3715. !       else {
  3716. !       new_buf = ALLOC_BUF(new_size);
  3717. !       memcpy(new_buf, _buffer, _size);
  3718. !       }
  3719.         if (new_buf == NULL) {
  3720.   //      __ferror(fp) = 1;
  3721.         return EOF;
  3722.         }
  3723. -       _size = new_size;
  3724.   #if 0
  3725.         if (lenp == &_len) /* use '\0'-filling */
  3726. !       memset(new_buf + pos, 0, _size - pos);
  3727.   #endif
  3728. !       _buffer = new_buf;
  3729. !       setb(new_buf, new_buf + _size, 1);
  3730.       }
  3731.   
  3732. !   setp(_buffer, _buffer + _size);
  3733.     pbump(pos);
  3734. !   setg(_buffer, _buffer + get_pos, _buffer + _len);
  3735.     if (!flush_only) {
  3736.         *pptr() = (unsigned char) c;
  3737.         pbump(1);
  3738. --- 64,102 ----
  3739.       return put_len;
  3740.   }
  3741.   
  3742. ! int strstreambuf::overflow(int c /* = EOF */)
  3743.   {
  3744.     const int flush_only = c == EOF;
  3745. +   if (_flags & _S_NO_WRITES)
  3746. +       return flush_only ? 0 : EOF;
  3747.     size_t pos = pptr() - pbase();
  3748.     size_t get_pos = gptr() - pbase();
  3749.     if (pos > _len) _len = pos;
  3750. !   if (pos >= blen() + flush_only) {
  3751.         char *new_buf;
  3752. !       size_t new_size = 2 * blen();
  3753. !       if (frozen()) /* not allowed to enlarge */
  3754.         return EOF;
  3755. !       new_buf = (char*)(*_allocate_buffer)(new_size);
  3756. !       memcpy(new_buf, base(), blen());
  3757.         if (new_buf == NULL) {
  3758.   //      __ferror(fp) = 1;
  3759.         return EOF;
  3760.         }
  3761.   #if 0
  3762.         if (lenp == &_len) /* use '\0'-filling */
  3763. !       memset(new_buf + pos, 0, blen() - pos);
  3764.   #endif
  3765. !       if (_base) {
  3766. !       (*_free_buffer)(_base);
  3767. !       _base = NULL; // So setb() won't try to delete _base.
  3768. !       }
  3769. !       setb(new_buf, new_buf + new_size, 1);
  3770.       }
  3771.   
  3772. !   setp(base(), ebuf());
  3773.     pbump(pos);
  3774. !   setg(base(), base() + get_pos, base() + _len);
  3775.     if (!flush_only) {
  3776.         *pptr() = (unsigned char) c;
  3777.         pbump(1);
  3778. ***************
  3779. *** 118,124 ****
  3780.   {
  3781.       size_t ppos = pptr() - pbase();
  3782.       if (ppos > _len) _len = ppos;
  3783. !     setg(_buffer, gptr(), _buffer + _len);
  3784.       if (gptr() < egptr())
  3785.       return *gptr();
  3786.       else
  3787. --- 108,114 ----
  3788.   {
  3789.       size_t ppos = pptr() - pbase();
  3790.       if (ppos > _len) _len = ppos;
  3791. !     setg(base(), gptr(), base() + _len);
  3792.       if (gptr() < egptr())
  3793.       return *gptr();
  3794.       else
  3795. ***************
  3796. *** 125,198 ****
  3797.       return EOF;
  3798.   }
  3799.   
  3800. - strstreambuf::strstreambuf()
  3801. - {
  3802. -     _frozen = 0;
  3803. -     _len = 0;
  3804. -     _size = 128;
  3805. -     _buffer = ALLOC_BUF(_size);
  3806. -     setb(_buffer, _buffer+_size);
  3807. -     setp(_buffer, _buffer+_size);
  3808. -     setg(_buffer, _buffer, _buffer);
  3809. - }
  3810.   
  3811. ! strstreambuf::strstreambuf(int initial)
  3812.   {
  3813. -     _frozen = 0;
  3814.       _len = 0;
  3815. !     if (initial < 16)
  3816. !     initial = 16;
  3817. !     _size = initial;
  3818. !     _buffer = ALLOC_BUF(_size);
  3819. !     setb(_buffer, _buffer+_size);
  3820. !     setp(_buffer, _buffer+_size);
  3821. !     setg(_buffer, _buffer, _buffer);
  3822.   }
  3823.   
  3824. ! strstreambuf::strstreambuf(char *ptr, size_t size, char *pstart)
  3825.   {
  3826. -     _frozen = 1;
  3827.       if (size == 0)
  3828. !     _size = strlen(ptr);
  3829. !     else if (size < 0) {
  3830.       // If size is negative 'the characters are assumed to
  3831. !     // continue indefinitely.'
  3832. !     // The following semi-portable kludge tries to do that.
  3833. !     // It assumes that sizeof(long) == sizeof(pointer).
  3834. !     // Hence, (unsigned long)(-1) should be the largest
  3835. !     // possible address.
  3836.       unsigned long highest = (unsigned long)(-1);
  3837.       // Pointers are signed on some brain-damaged systems, in
  3838.       // which case we divide by two to get the maximum signed address.
  3839.       if  ((char*)highest < ptr)
  3840.           highest >>= 1;
  3841. !     _size = (char*)highest - ptr;
  3842.       }
  3843. !     else
  3844. !     _size = size;
  3845. !     _buffer = ptr;
  3846. !     setb(_buffer, _buffer+_size);
  3847.       if (pstart) {
  3848. !     setp(_buffer, _buffer+_size);
  3849. !     pbump(pstart-_buffer);
  3850. !     setg(_buffer, _buffer, pstart);
  3851.       }
  3852.       else {
  3853. !     setp(_buffer, _buffer); 
  3854. !     setg(_buffer, _buffer, _buffer+_size);
  3855.       }
  3856. !     _len = egptr() - _buffer;
  3857.   }
  3858.   
  3859.   strstreambuf::~strstreambuf()
  3860.   {
  3861. !     if (_frozen == 0)
  3862. !         FREE_BUF(_buffer);
  3863.   }
  3864.   
  3865. ! virtual streampos strstreambuf::seekoff(streamoff off, _seek_dir dir,
  3866.                       int mode /*=ios::in|ios::out*/)
  3867.   {
  3868.       size_t cur_size = pcount();
  3869.       streampos new_pos = EOF;
  3870.   
  3871. --- 115,189 ----
  3872.       return EOF;
  3873.   }
  3874.   
  3875.   
  3876. ! void strstreambuf::init_dynamic(_alloc_type alloc, _free_type free,
  3877. !                 _G_size_t initial_size)
  3878. !                 
  3879.   {
  3880.       _len = 0;
  3881. !     if (initial_size < 16)
  3882. !     initial_size = 16;
  3883. !     _allocate_buffer = alloc ? alloc : default_alloc;
  3884. !     _free_buffer = free ? free : default_free;
  3885. !     char * buf = (char*)(*_allocate_buffer)(initial_size);
  3886. !     setb(buf, buf + initial_size, 1);
  3887. !     setp(buf, buf + initial_size);
  3888. !     setg(buf, buf, buf);
  3889.   }
  3890.   
  3891. ! void strstreambuf::init_static(char *ptr, long size, char *pstart)
  3892.   {
  3893.       if (size == 0)
  3894. !     size = strlen(ptr);
  3895. !     else if ((long)size < 0) {
  3896.       // If size is negative 'the characters are assumed to
  3897. !     // continue indefinitely.'  This is kind of messy ...
  3898. ! #if 1
  3899. !     size = 512;
  3900. !     // Try increasing powers of 2, as long as we don't wrap around.
  3901. !     // This can lose in pathological cases (ptr near the end
  3902. !     // of the address space).  A better solution might be to
  3903. !     // adjust the size on underflow/overflow.  FIXME.
  3904. !     for (long s; s = 2*size, s > 0 && ptr + s > ptr && s < 0x4000000L; )
  3905. !         size = s;
  3906. !     size = s;
  3907. ! #else
  3908. !     // The following semi-portable kludge assumes that
  3909. !     // sizeof(unsigned long) == sizeof(char*). Hence,
  3910. !     // (unsigned long)(-1) should be the largest possible address.
  3911.       unsigned long highest = (unsigned long)(-1);
  3912.       // Pointers are signed on some brain-damaged systems, in
  3913.       // which case we divide by two to get the maximum signed address.
  3914.       if  ((char*)highest < ptr)
  3915.           highest >>= 1;
  3916. !     size = (char*)highest - ptr;
  3917. ! #endif
  3918.       }
  3919. !     setb(ptr, ptr+size);
  3920.       if (pstart) {
  3921. !     setp(ptr, ebuf());
  3922. !     pbump(pstart-ptr);
  3923. !     setg(ptr, ptr, pstart);
  3924.       }
  3925.       else {
  3926. !     setp(ptr, ptr); 
  3927. !     setg(ptr, ptr, ebuf());
  3928.       }
  3929. !     _len = egptr() - ptr;
  3930.   }
  3931.   
  3932.   strstreambuf::~strstreambuf()
  3933.   {
  3934. !     if (_base && !(_flags & _S_USER_BUF))
  3935. !         (_free_buffer)(_base);
  3936. !     _base = NULL;
  3937.   }
  3938.   
  3939. ! streampos strstreambuf::seekoff(streamoff off, _seek_dir dir,
  3940.                       int mode /*=ios::in|ios::out*/)
  3941.   {
  3942. +     _allocate_buffer = default_alloc;
  3943. +     _free_buffer = default_free;
  3944.       size_t cur_size = pcount();
  3945.       streampos new_pos = EOF;
  3946.   
  3947. ***************
  3948. *** 210,216 ****
  3949.       }
  3950.       if (off < 0 || (size_t)off > cur_size)
  3951.           return EOF;
  3952. !     setg(_buffer, _buffer + off, _buffer + cur_size);
  3953.       new_pos = off;
  3954.       }
  3955.   
  3956. --- 201,207 ----
  3957.       }
  3958.       if (off < 0 || (size_t)off > cur_size)
  3959.           return EOF;
  3960. !     setg(base(), base() + off, base() + cur_size);
  3961.       new_pos = off;
  3962.       }
  3963.   
  3964. ***************
  3965. *** 228,235 ****
  3966.       }
  3967.       if (off < 0 || (size_t)off > cur_size)
  3968.           return EOF;
  3969. !     pbump(_buffer + off - pptr());
  3970.       new_pos = off;
  3971.       }
  3972.       return new_pos;
  3973.   }
  3974. --- 219,233 ----
  3975.       }
  3976.       if (off < 0 || (size_t)off > cur_size)
  3977.           return EOF;
  3978. !     pbump(base() + off - pptr());
  3979.       new_pos = off;
  3980.       }
  3981.       return new_pos;
  3982. + }
  3983. + 
  3984. + int strstreambuf::pbackfail(int c)
  3985. + {
  3986. +     if ((_flags & _S_NO_WRITES) && c != EOF)
  3987. +     return EOF;
  3988. +     return backupbuf::pbackfail(c);
  3989.   }
  3990. *** 1.1    1992/03/22 07:42:32
  3991. --- xsfile.cc    1993/02/22 17:06:46
  3992. ***************
  3993. *** 20,38 ****
  3994.   #endif
  3995.   #include <xsfile.h>
  3996.   
  3997. ! SFile::SFile(const char *filename, size_t size, int mode, int prot)
  3998.   : fstream(filename, mode, prot)
  3999.   { 
  4000.     sz = size; 
  4001.   }
  4002.   
  4003. ! SFile::SFile(int fd, size_t size)
  4004.   : fstream(fd)
  4005.   { 
  4006.     sz = size; 
  4007.   }
  4008.   
  4009. ! void SFile::open(const char *name, size_t size, int mode, int prot)
  4010.   {
  4011.       fstream::open(name, mode, prot);
  4012.       sz = size;
  4013. --- 20,38 ----
  4014.   #endif
  4015.   #include <xsfile.h>
  4016.   
  4017. ! SFile::SFile(const char *filename, _G_size_t size, int mode, int prot)
  4018.   : fstream(filename, mode, prot)
  4019.   { 
  4020.     sz = size; 
  4021.   }
  4022.   
  4023. ! SFile::SFile(int fd, _G_size_t size)
  4024.   : fstream(fd)
  4025.   { 
  4026.     sz = size; 
  4027.   }
  4028.   
  4029. ! void SFile::open(const char *name, _G_size_t size, int mode, int prot)
  4030.   {
  4031.       fstream::open(name, mode, prot);
  4032.       sz = size;
  4033.